Video generation

Every video model in the catalog runs on one async surface: POST /v1/llm/videos/jobs returns a job_id in under a second, and you poll GET /v1/llm/videos/jobs/{job_id} until the status is terminal. There is no synchronous video endpoint — nothing to migrate, no connection to lose.

You are charged only when a poll returns a video.url. A failed or timed-out job costs nothing.

Quick start

The catalog covers text-to-video (t2v — prompt only), image-to-video (i2v — pass image_url as the start frame), first/last-frame interpolation, reference-to-video, and video-to-video motion control (v2v — pass video_url plus image_url for the conditioning frame). Avatar SKUs take an audio reference URL in the request body.

import time, requests

BASE = "https://api.gpuniq.com/v1/llm"
HEADERS = {"X-API-Key": "gpuniq_your_key"}

# 1. Kickoff
start = requests.post(
    f"{BASE}/videos/jobs",
    headers=HEADERS,
    json={
        "model": "kling-2-6",
        "prompt": "A small black cat slowly turns toward the camera at golden hour",
        "duration": 5,
        "audio": False,          # opt-in, doubles price on Kling 2.6 / 3.0
        "resolution": "1080p",   # 720p | 1080p | 4k (where supported)
    },
).json()
job_id = start["data"]["job_id"]
print(f"job: {job_id}, est cost: ${start['data']['estimated_cost_usd']}")

# 2. Poll — video models deliver in 30-90s; budget 5 minutes for the slowest variants
deadline = time.time() + 300
while time.time() < deadline:
    time.sleep(3)
    r = requests.get(f"{BASE}/videos/jobs/{job_id}", headers=HEADERS).json()
    d = r["data"]
    if d["status"] == "completed":
        print(f"video: {d['video']['url']}")
        print(f"cost: ${d['cost_usd']}, balance: ${d['balance_usd']}")
        break
    if d["status"] == "failed":
        print("failed:", d.get("error"))
        break

Request body

Duration by model

duration is not a free integer. Each family accepts its own set and anything outside it comes back as a 400 naming the legal values — we do not round to the nearest supported length, because silently rendering (and billing) 8 seconds when you asked for 5 is worse than a refusal.

Reference media: what format to send

Every media field takes a URL string, never an uploaded file part — there is no multipart endpoint. Two forms are accepted:

Upstream renderers only accept URLs, so a data: URI on a video or audio field is materialised into a real link on our side before dispatch. You do not have to host anything yourself to use a reference clip.

Hosted links are re-hosted when the host misdescribes them. Upstream validators judge a reference clip by the Content-Type the host declares, not by the bytes — so a perfectly good MP4 served as application/octet-stream used to be refused on sight. GPUniq now probes that header and, when it is not a video/* type, fetches the file and re-serves it correctly before dispatch.

Serving a reference from a bucket with the right Content-Type is still the fastest path: it skips the extra fetch entirely. What the upstream fetch requires, in the order things usually go wrong:

1. A direct link to the file, not to a viewer page. The response must be the bytes themselves.
2. No authentication, no redirect chain to a login page. The fetcher is anonymous and has no cookies.
3. A media Content-Type — video/mp4, image/jpeg, audio/mpeg. Handled for you when it is wrong, at the cost of one extra round trip.
4. A file extension that matches the content where possible — some upstreams sniff the URL path before they sniff the body.

Size and format limits:

Reference video resolution and container are unrestricted: 1080p/4K and non-MP4 sources are transcoded to ≤720p MP4 on our side before dispatch, so send source footage as-is. Keep in mind that a data URI inflates by ~33% over the raw bytes and counts against the request body limit — for anything above a few MB, host it and send a URL.

Which model takes which reference input

Sending a field the chosen model has no input for is a 400 at submit, not a silent drop. That is deliberate: previously a request carrying reference_image_urls could render on one attempt and be refused on the next, depending on which internal route served it. Capability is now resolved before dispatch, so the same request gets the same answer every time.

For subject or style reference on a model with no reference_image_urls column, use image_url as the start frame — or move to the Seedance 2 line (seedance-2 / seedance-2-5), which has the widest reference surface in the catalog.

Motion control is the strictest shape here: kling-2-6-motion-control and kling-3-0-motion-control need both image_url (the character / subject frame) and video_url (the motion to transfer). Either one alone is a 400 naming the missing field.

Response

The kickoff returns immediately with the GPUniq job id, the resolved parameter snapshot, and the cost estimate. Internal routing is opaque — the same job_id is valid across fallbacks, and the user-facing price stays stable.

// POST /v1/llm/videos/jobs
{
  "job_id": "vid_e93e98c7ca5e4982876b",
  "status": "pending",
  "model": "kling-2-6",
  "estimated_cost_usd": 0.315,
  "config": { "resolution": "1080p", "audio": false, "duration": 5, "task": "t2v", "mode": null }
}

// GET /v1/llm/videos/jobs/{job_id} — completed
{
  "job_id": "vid_e93e98c7ca5e4982876b",
  "status": "completed",
  "model": "kling-2-6",
  "video": {
    "url": "https://cdn.example.com/.../output.mp4",
    "stored_url": "https://api.gpuniq.com/v1/llm/media/8xK2p….mp4",
    "stored_expires_in_days": 7
  },
  "cost_usd": 0.315,
  "balance_usd": 9.17825791,
  "config": { "resolution": "1080p", "audio": false, "duration": 5, "task": "t2v", "mode": null }
}

The polling endpoint transparently falls back across internal routes if the first attempt fails — your job_id and the user-facing price stay stable across fallbacks. Internal route identifiers are deliberately omitted from the public response; they live only in admin/operator logs.

Where delivered media lives

Every generated image and video is also mirrored to GPUniq storage, and the response tells you where:

Why it matters: the upstream video.url points at the rendering provider's CDN, and its lifetime is set by them, not by us. If you store that link rather than the bytes, it can stop resolving well before you expect. stored_url is ours and lives exactly as long as the field says.

Two practical notes. For images the copy is written before the response is sent, so url works the moment you receive it. For videos the copy runs in the background — a clip is tens of megabytes and we would rather not make the delivering poll wait on it — so stored_url becomes valid shortly after the response; url is live immediately either way. And if storage is briefly unavailable the stored_url / url fields are simply absent: the generation still succeeds and is still delivered, because a storage hiccup is never allowed to fail a render you paid for.

Models & pricing

Video models are billed per delivered video or per second of output — the Headline / video column is the cheapest default configuration, not a flat rate. The exact amount charged is always in the completion response's cost_usd.

Veo 3.1 (Google)

All three Veo tiers are billed per video, by resolution. Duration can be 4, 6 or 8 seconds (default 8) and does not change the price.

• First + last frame — image_url (first frame) + last_frame_url (last frame) on all three tiers; the clip interpolates between the two frames and the order is honoured.
• Reference-to-video — up to 3 reference images via reference_image_urls on veo-3-1-fast / veo-3-1-lite (8-second clips only; not available on Quality). Mutually exclusive with last_frame_url.
• aspect_ratio: 16:9 (default), 9:16, or auto (follows the input image geometry).
• On a provider fallback the charge follows the serving upstream's rate — the exact amount is always in the completion cost_usd.

Kling O3

Kling O3 is billed per second, by resolution and audio flag, for clips of 3–15 seconds (default 5). Prompts are capped at 2500 characters.

• Text-to-video — prompt only; aspect_ratio is 16:9 (default), 9:16 or 1:1.
• Image-to-video — image_url (start frame), optionally with last_frame_url (end frame). The aspect ratio follows the frame.
• Reference-to-video — up to 4 reference images via reference_image_urls, which define the subject/style. image_url / last_frame_url may ride along as start / end anchors.
• No reference video. video_url / video_urls are rejected with a 400 on this model: the upstream accepts a clip at submit and then fails the render. For video-to-video use kling-2-6-motion-control / kling-3-0-motion-control.

Seedance (ByteDance)

Seedance is ByteDance's text-to-video / image-to-video family — fast, photoreal clips, well suited to product shots, social content, and image-to-video animation of a still frame. Six SKUs are in the catalog, and they do not all price the same way, so read this before budgeting a batch.

Choosing between them:

• seedance-1-5-pro — cheapest ($0.160/clip), newest of the "pro" tier. Best default for short 720p clips where you want a fixed, predictable price.
• seedance-1-0-pro — the previous pro model ($0.210/clip); keep using it only if you've tuned prompts against it.
• seedance-2 — the high-quality tier with the widest resolution menu (up to 4k). Priced per second, so it scales with clip length.
• seedance-2-5 — the newest ByteDance line and the flagship of the family. Best motion coherence and the only SKU that renders up to 30 seconds in one job, but it renders 480p / 720p only and is the most expensive per second. Reach for it when quality and clip length matter more than cost.
• seedance-2-fast / seedance-2-mini — the same Seedance 2 grammar at a fraction of the price (480p / 720p, 4–15s). Use them for drafts, batch previews and A/B prompt work, then re-render the keeper on seedance-2 or seedance-2-5.

Text-to-video (default) needs only a prompt. Image-to-video animates a still: pass image_url (an https URL or data: URI) as the start frame. Every Seedance SKU supports both.

import time, requests

BASE = "https://api.gpuniq.com/v1/llm"
HEADERS = {"X-API-Key": "gpuniq_your_key"}

# Image-to-video with the flagship, 6-second clip
start = requests.post(
    f"{BASE}/videos/jobs",
    headers=HEADERS,
    json={
        "model": "seedance-2",
        "prompt": "the product slowly rotates on a marble pedestal, soft studio light",
        "image_url": "https://example.com/product.jpg",  # start frame → image-to-video
        "duration": 6,          # seedance-2 bills per second → 6 × $0.272 = $1.632
    },
).json()["data"]
job_id = start["job_id"]
print("estimated:", start["estimated_cost_usd"])   # 1.632

deadline = time.time() + 300
while time.time() < deadline:
    time.sleep(3)
    d = requests.get(f"{BASE}/videos/jobs/{job_id}", headers=HEADERS).json()["data"]
    if d["status"] == "completed":
        print("video:", d["video"]["url"], "cost:", d["cost_usd"])
        break
    if d["status"] == "failed":
        print("failed:", d.get("error"))
        break

Seedance shares the standard video job API. The two -pro SKUs (seedance-1-0-pro, seedance-1-5-pro) do text-to-video and image-to-video only: duration and image_url are the fields that matter, aspect_ratio is honoured where the upstream supports it, and fields specific to other families (audio, mode, resolution tiers, video_url) are ignored.

The Seedance 2 line (seedance-2, seedance-2-5, seedance-2-fast, seedance-2-mini) accepts more of the request body. On top of t2v and i2v it supports:

• First + last frame — pass image_url (start) together with last_frame_url (end); the clip interpolates between the two frames.
• Reference-to-video — condition the render on reference clips (video_url / video_urls), reference images (reference_image_urls) and reference audio tracks (audio_url / audio_urls), in any combination. The counts are per SKU: seedance-2, -fast and -mini take 9 images, 3 clips and 3 audio tracks, seedance-2-5 takes 30 images, 10 clips and 10 audio tracks. Audio references need at least one image or video reference alongside them (the API returns a 400 otherwise). A single image_url sent together with any reference input is treated as a subject reference rather than a start frame. First/last-frame and reference-to-video are mutually exclusive — when any reference input is attached, last_frame_url is dropped.
• Resolution choice — via resolution; the per-second price scales with it (see the pricing tables above). The menu is per SKU: seedance-2 renders 480p / 720p / 1080p / 4k, while seedance-2-5, -fast and -mini render 480p / 720p only and return a 400 for anything above.
• Generated audio track — set audio: true to have the model generate sound for the clip. Default is false; we always send the flag explicitly, so an omitted field means a silent clip.

duration applies to every Seedance SKU. seedance-2, -fast and -mini accept 4–15 seconds; seedance-2-5 accepts 4–30. On the Seedance 2 line, aspect_ratio additionally accepts auto, 21:9, 4:3 and 3:4 — omit it in i2v mode to follow the input frame's geometry.

seedance-2 also accepts a seed. Be aware of what it actually buys: keeping the seed fixed while everything else stays identical makes two renders markedly more alike than two unseeded ones, but they will not be identical — the model is not bit-reproducible, so treat the seed as a similarity control rather than a repeat button. A seeded request is routed to the one upstream that implements the parameter; if that route is unavailable the clip is still rendered, without the seed. On seedance-2-5, -fast and -mini the field is accepted but has no effect — the upstreams serving those SKUs expose no seed parameter, so the render is always random.

Reference-file limits: videos 2–15s combined (up to 30s on seedance-2-5), ≤50MB total; images JPG/PNG/WebP; audio MP3/WAV, ≤15s combined (30s on seedance-2-5). Video resolution and container are unrestricted — 1080p/4K clips and non-MP4 formats (webm, MKV, …) are automatically converted to ≤720p MP4 on our side before dispatch, so send your source footage as-is.

seedance-2-5 — exact request contract

The reference sheet for Seedance 2.5 specifically. Everything below is what the GPUniq API enforces today — a value outside these ranges is a 400 invalid_request at submit, not a silent clamp.

Endpoint. There is no model-specific route. Seedance 2.5 uses the standard async video-job API:

POST https://api.gpuniq.com/v1/llm/videos/jobs      → { job_id, estimated_cost_usd, ... }
GET  https://api.gpuniq.com/v1/llm/videos/jobs/{job_id}   → poll every 3–5 s

Auth is X-API-Key: gpuniq_... on both calls (a JWT works too). The kickoff returns in under a second; the job id stays valid across internal provider fallbacks and lives in our job store for 60 minutes, after which a poll returns job_not_found (404). Renders usually land in a few minutes; a job that shows no upstream progress for 30 minutes is failed definitively rather than left polling.

Model slug: seedance-2-5 (exactly this string in the model field; it is also listed by GET /v1/llm/models/catalog).

Request fields

Generation modes. Four, and the frame modes and reference modes are mutually exclusive:

1. Text-to-video — prompt only.
2. Image-to-video — prompt + image_url (start frame).
3. First + last frame — prompt + image_url + last_frame_url. Order matters: image_url is always the FIRST frame.
4. Reference-to-video — prompt + any of reference_image_urls / video_url / video_urls / audio_url / audio_urls. Attaching any reference input switches the job to reference mode: image_url is then read as one more subject reference and last_frame_url is not applied. Audio references require at least one image or video reference alongside them, otherwise the API returns a 400.

Reference-media limits on this SKU

Field names, and how to tell an input arrived. The model's own passport spells the reference arrays reference_video_urls / reference_image_urls / reference_audio_urls, and the start frame first_frame_url. Those spellings are accepted here and folded onto the names in the table above (so are their camelCase forms, reference_videos, end_frame_url, source_video_url and duration_seconds). A field name we don't recognise that looks like an attachment — motion_clip, image_urls, a typo of a real one — is a 400 naming it, never a render that quietly ignored it.

Every kickoff answers the question directly in data.inputs:

"inputs": {
  "mode": "reference-to-video",
  "reference_videos": 1,
  "reference_images": 2,
  "reference_audio": 0,
  "start_frame": false,
  "end_frame": false,
  "notes": ["`image_url` ships as reference image #1 — address it as @Image1 in the prompt."]
}

"reference_videos": 0 on a job built around a reference clip means the clip never reached the model — check that on the first call of a new integration rather than after a batch of renders.

Audio generation. "audio": true turns on the model's native soundtrack generation for the rendered clip. It is independent of audio_url / audio_urls, which are input references (pacing / lip-sync anchors), not output settings. The flag is always sent explicitly upstream, so omitting it reliably yields a silent clip.

Editing / extension

Supported on this SKU via video_task. Attach the clip you want to work on as video_url (or video_urls), address it in the prompt as @Video 1, and set:

Both modes inherit the source's aspect ratio, so aspect_ratio is ignored, and both are mutually exclusive with image_url / last_frame_url — there is no start frame to set when the input is a whole clip. Scope an edit with plain language (Keep the storefront, lighting and camera move exactly unchanged); an edit aims at continuity, not pixel-identical preservation of the untouched regions.

Cost. Billed exactly like reference-to-video: (source seconds + output seconds) × the reference rate for your resolution. A 10 s source edited at 480p bills 20 s; the same source extended by 4 s bills 14 s. Because an edit's output length isn't knowable at submit, the kickoff estimated_cost_usd assumes the source's measured length and the final cost_usd is recomputed from the upstream invoice.

The adjacent post-processing surface is Topaz video upscaling (POST /v1/llm/topaz/video/jobs, see Topaz).

Cost

Billed per second of output, i.e. rate × duration. In reference-to-video mode the upstream meters (input + output) seconds, so the reference-clip length is added to the billed seconds, capped at 30 s. Because clip length isn't knowable at submit, the kickoff estimated_cost_usd assumes that 30 s cap and the final cost_usd is recomputed from the measured length — a ref job with short clips settles well under its estimate.

Worked examples:

• 5 s, 720p, t2v → 5 × $0.426 = $2.13
• 30 s, 720p, t2v → 30 × $0.426 = $12.78
• 10 s, 480p, t2v → 10 × $0.198 = $1.98
• 8 s, 720p, ref-to-video with a 6 s clip → estimated (8 + 30) × $0.255 = $9.69, billed (8 + 6) × $0.255 = $3.57

Example request

# 1. Kick off — 8-second 720p reference-to-video with generated audio
curl -X POST https://api.gpuniq.com/v1/llm/videos/jobs \
  -H "X-API-Key: gpuniq_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2-5",
    "prompt": "the model walks toward camera through neon-lit rain, slow dolly-in, cinematic",
    "duration": 8,
    "resolution": "720p",
    "aspect_ratio": "9:16",
    "reference_image_urls": [
      "https://example.com/subject-front.jpg",
      "https://example.com/subject-side.jpg"
    ],
    "video_urls": ["https://example.com/motion-ref.mp4"],
    "audio": true
  }'

# → {"exception":0,"data":{"job_id":"vid_e93e98c7ca5e4982876b",
#                          "status":"pending","estimated_cost_usd":9.69,
#                          "inputs":{"mode":"reference-to-video",
#                                    "reference_videos":1,"reference_images":2,
#                                    "reference_audio":0,...},...}}

# 2. Poll every 3–5 s until status is completed or failed
curl https://api.gpuniq.com/v1/llm/videos/jobs/vid_e93e98c7ca5e4982876b \
  -H "X-API-Key: gpuniq_your_key"

# → {"exception":0,"data":{"status":"completed",
#                          "video":{"url":"https://.../out.mp4"},
#                          "cost_usd":3.57,"balance_usd":41.02}}

The simplest possible call is just the slug and a prompt — everything else has a default:

curl -X POST https://api.gpuniq.com/v1/llm/videos/jobs \
  -H "X-API-Key: gpuniq_your_key" \
  -H "Content-Type: application/json" \
  -d '{"model":"seedance-2-5","prompt":"a paper boat drifting down a rain gutter"}'