Skip to content

Text to Video API

Turn a written prompt into a video file with one API call. 8 models through one endpoint, billed per second of output from $0.042/s. Failed tasks are not charged.

Text to video API models

Every model below takes a text prompt and returns a video. They differ in output resolution, clip length and price.

Text to video models
ModelResolutionsClip lengthFrom
Seedance 2.5480p, 720p and 1080p4–30 s$0.132/s480p · 26.4 Credits/s
Seedance 2.0 Mini480p and 720p4–15 s$0.042/s480p · 8.4 Credits/s
Seedance 2.0 Fast480p and 720p4–15 s$0.067/s480p · 13.4 Credits/s
Seedance 2.0 Pro480p, 720p, 1080p and 4K4–15 s$0.084/s480p · 16.8 Credits/s
Kling 4.0720p and 1080p3–30 s$0.157/s720p · 31.4 Credits/s
Wan 3.0480p, 720p and 1080p2–30 s$0.05/s480p · 10 Credits/s
Wan 3.0 Prime720p2–30 s$0.14/s720p · 28 Credits/s
MiniMax H3768p4–15 s$0.09/s768p · 18 Credits/s

How a text to video request works

Send POST /v1/generations with the model and its input, and get a task ID back at once. The input uses the model's own field names, and its resolution picks the per-second rate. Poll the task until it closes, or pass a webhook endpoint and get a signed event when it finishes. Finished files are kept for 7 days.

This example asks Seedance 2.5 for a 5 second 720p clip.

cURL

API=https://api.vizoapi.com/v1
AUTH="Authorization: Bearer $VIZO_API_KEY"

# Create the task once and keep its ID.
ID=$(curl -fsS $API/generations -H "$AUTH" -H "Content-Type: application/json" \
  -d '{
  "model": "seedance-2-5",
  "input": {
    "content": [
      {
        "type": "text",
        "text": "A slow dolly shot through a rainy neon street"
      }
    ],
    "resolution": "720p",
    "ratio": "16:9",
    "duration": 5
  },
  "metadata": {
    "client_reference": "my-unique-reference-1"
  }
}' | jq -r .id)

# Poll until the task closes, then read its status and result.
until curl -fsS $API/generations/$ID -H "$AUTH" | jq -e '.closed_at != null' > /dev/null; do sleep 5; done
curl -fsS $API/generations/$ID -H "$AUTH" | jq '{status, result}'

Python

import os, time, requests

api = "https://api.vizoapi.com/v1"
headers = {"Authorization": f"Bearer {os.environ['VIZO_API_KEY']}"}

# Create the task once and keep its ID.
res = requests.post(f"{api}/generations", headers=headers, timeout=30, json={
    "model": "seedance-2-5",
    "input": {"content": [{"type": "text", "text": "A slow dolly shot through a rainy neon street"}], "resolution": "720p", "ratio": "16:9", "duration": 5},
    "metadata": {"client_reference": "my-unique-reference-1"},
})
res.raise_for_status()
task = res.json()

# Poll until the task closes, then read its status and result.
while True:
    t = requests.get(f"{api}/generations/{task['id']}", headers=headers, timeout=30).json()
    if t.get("closed_at"):
        break
    time.sleep(5)
print(t["status"], t.get("result"))

Node.js

const api = "https://api.vizoapi.com/v1";
const headers = { Authorization: `Bearer ${process.env.VIZO_API_KEY}`, "Content-Type": "application/json" };

// Create the task once and keep its ID.
const res = await fetch(`${api}/generations`, { method: "POST", headers, body: JSON.stringify({
  model: "seedance-2-5",
  input: {
    "content": [
      {
        "type": "text",
        "text": "A slow dolly shot through a rainy neon street"
      }
    ],
    "resolution": "720p",
    "ratio": "16:9",
    "duration": 5
  },
  metadata: { client_reference: "my-unique-reference-1" },
}) });
if (!res.ok) throw new Error(await res.text());
const task = await res.json();

// Poll until the task closes, then read its status and result.
let t;
do {
  await new Promise((ok) => setTimeout(ok, 5000));
  t = await (await fetch(`${api}/generations/${task.id}`, { headers })).json();
} while (!t.closed_at);
console.log(t.status, t.result);

The quick start walks through a full request, and model inputs shows the input of each model family.

Text to video API pricing

Each model publishes a rate in Credits per second of output video, one per resolution. Credits are held when a task is accepted and charged on delivery, and the charge follows the length the model reports. If generation fails, the hold is released and nothing is charged. Credits never expire and there is no subscription.

See every rate on the pricing page, or open a model page for its full price table.

Text to video API FAQ

What is a text to video API?
An API that takes a written prompt and returns a generated video file. With VizoAPI you send the prompt and the output settings to one endpoint, and download the video when the task finishes.
Which models support text to video?
Seedance 2.5, Seedance 2.0 Mini, Seedance 2.0 Fast, Seedance 2.0 Pro, Kling 4.0, Wan 3.0, Wan 3.0 Prime and MiniMax H3. Each model page lists its resolutions, clip lengths and prices. Browse all models.
How much does the text to video API cost?
Video is billed per second of output, at a rate set by the model and resolution. The lowest rate is 8.4 Credits/s ($0.042/s), for Seedance 2.0 Mini at 480p. The final charge follows the actual length the model reports. See all prices.
How long can a generated video be?
Between 2 and 30 seconds, depending on the model. Seedance 2.5, Kling 4.0, Wan 3.0 and Wan 3.0 Prime go up to 30 seconds. The table above gives each model's range.
Am I charged when a task fails?
No. If generation fails, or nothing is delivered within 24 hours of acceptance, all held Credits are released.
How do I get the finished video?
Send POST /v1/generations and get a task ID back at once. Poll GET /v1/generations/{id}, or receive a webhook when the task finishes. Finished files are kept for 7 days, so download what you want to keep. Read the webhooks guide.