# How much does AI video generation cost per clip via API?

> AI video generation via API costs $0.54 per 6-second clip ($0.09 per second) for vibiz/video, with other models billed at live rates per second.

**AI video generation costs $0.54 per six-second clip—exactly $0.09 per second—using the standard `vibiz/video` model via the API.** If you call specialized third-party media models by id (such as Kling, Seedance, or Veo), generation is billed from your credits at live market rates based on requested duration, with a hard per-call cap of $10. Every video generated through a project is automatically stored in your project's Files drive with a permanent URL.

Budgeting for video generation in automated pipelines, agents, and SaaS applications requires understanding per-clip pricing, duration defaults, and storage mechanics. Here is how video pricing breaks down across models, how to initiate asynchronous video jobs, and how to guard against runaway spend.

## How video generation pricing works

Unlike chat completions that charge per input and output token, video models charge per clip or per second of output. On thelastapi, video pricing falls into two categories:

1. **The default video tier (`vibiz/video`)**: This tier runs Lightricks LTX-2.5 Fast. It produces 6-second clips at 720p resolution with sound from a prompt or an image input. Each generation has a fixed price of $0.54 per video. That comes out to $0.09 per second of generated video.
2. **Third-party video models by ID**: You can also target specific models directly—including Kling, Seedance, Veo, Hailuo, and Wan—using their exact model IDs. These models charge their live prices, metered by duration in seconds (defaulting to 5 seconds when unstated) or by video clip. One call is capped at $10 (`call_too_expensive`).

Here is a direct comparison of media costs across the platform:

| Tier / Model | Underlying Model | Format / Length | Price (USD) | Effective Price / Second |
| --- | --- | --- | --- | --- |
| `vibiz/video` | LTX-2.5 Fast (Lightricks) | 6 seconds, 720p with sound | $0.54 per video | $0.09 / s |
| Media models by ID | Kling, Seedance, Veo, Wan, etc. | Varies by model input | Live price book | Varies (5s default) |
| `vibiz/image` | Nano Banana 2 (Google) | Single still image | ~$0.067 per image | N/A |
| `vibiz/image-pro` | Nano Banana 2.1 (Google) | Single still image | ~$0.034 per image | N/A |
| `vibiz/image-text` | GPT-5.4 Image 2 (OpenAI) | Text in image | ~$0.04 per image | N/A |

To check live pricing across available media models from your terminal, run:

```bash
vibiz media-models --category image-to-video
```

For more details on generating accompanying visual assets, see [an image generation API for developers: Nano Banana and GPT Image on one key](https://thelastapi.dev/blog/image-generation-api-developers).

## Generating a video via the API

Video generation takes time, so the API handles it as an asynchronous job. You send a request to `POST /v1/ai/jobs`, receive an HTTP `202 Accepted` status with a job ID, and poll `GET /v1/ai/jobs/:id` until the job finishes.

Supported aspect ratios for `vibiz/video` are `16:9` and `9:16`. If you request `1:1`, the API returns a `16:9` video.

### Text-to-video request

You can create a video purely from a text prompt using plain HTTP:

```bash
curl https://thelastapi.dev/v1/ai/jobs \
  -H "Authorization: Bearer $VIBIZ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "video",
    "model": "vibiz/video",
    "input": {
      "prompt": "Drone shot skimming over turquoise ocean waves hitting black volcanic rocks at sunset",
      "aspect_ratio": "16:9"
    }
  }'
```

The initial response returns the job:

```json
{
  "id": "job_01k872abc...",
  "status": "pending"
}
```

### Animating an existing image (image-to-video)

You can pass an optional `image_url` inside `input` to use a starting still image. This works with public HTTPS URLs or links hosted in your project's Files:

```bash
curl https://thelastapi.dev/v1/ai/jobs \
  -H "Authorization: Bearer $VIBIZ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "video",
    "model": "vibiz/video",
    "input": {
      "prompt": "Camera slowly pans left while steam rises gently from the cup",
      "image_url": "https://thelastapi.dev/f/Qm9x123.../latte-art.png",
      "aspect_ratio": "16:9"
    }
  }'
```

You can read more about prompt structures and animation pipelines in [a text-to-video API: a six-second clip from a prompt](https://thelastapi.dev/blog/text-to-video-api).

### Calling external models by model ID

If you need a specific external engine, specify its model ID and pass any lab-specific parameters inside `model_input`:

```ts
import { vibiz } from '@vibiz/app';

const job = await vibiz.ai.jobs.create({
  type: 'video',
  model: 'kling-video/v2.1/master/image-to-video',
  input: {
    prompt: 'She smiles and waves at the camera',
    image_url: 'https://thelastapi.dev/f/Qm9x.../portrait.png',
    model_input: {
      duration: '10'
    }
  }
});
```

When unstated, duration on per-second models defaults to 5 seconds. Learn more about running unified media workloads across providers in [one API for image, video and voice AI models](https://thelastapi.dev/blog/one-api-image-video-voice-models).

## Fast testing from the CLI

When building out prototypes, you do not need to wire up polling scripts immediately. The `vibiz` CLI handles polling in the background and saves the output to a local file:

```bash
# Text-to-video
vibiz video "Bright streetlights reflecting on wet city pavement at night" -o city.mp4 --aspect 9:16

# Image-to-video
vibiz video "Animate the waterfall cascading down" -o falls.mp4 --from-image https://thelastapi.dev/f/Qm9x.../cliff.png
```

## How video hosting and file persistence work

Every video you generate using a project key is automatically saved to the project's permanent [Files](https://thelastapi.dev/docs/files) storage. You do not need to configure an external storage bucket or write download scripts before links expire.

When polling finishes with `status: "completed"`, the response payload includes:

```json
{
  "id": "job_01k872abc...",
  "status": "completed",
  "output": {
    "data": [
      {
        "file_id": "file_01k99video...",
        "file_url": "https://thelastapi.dev/f/Qm9x.../2026-10-28-drone-shot.mp4",
        "url": "https://thelastapi.dev/f/Qm9x.../2026-10-28-drone-shot.mp4",
        "expires_at": null
      }
    ]
  }
}
```

Files are named by generation date and prompt. Key rules to remember:
- **Project calls have permanent links**: The URL points to `https://thelastapi.dev/f/<key>/<name>`, where `<key>` is 32 random characters. It does not expire (`expires_at` is `null`).
- **Account keys without a project expire**: If you run a job using an account key (`vz_sk_...`) without passing the `X-Vibiz-Project: prj_...` header, the output is not saved to Files. Its link expires after 24 hours.
- **Environments are isolated**: Calls using a development key save to the development side of Files; production calls save to production.
- **Video limits**: Files accepts video formats in MP4, WebM, and QuickTime, with a file size limit of 50 MB per file.

You can inspect and retrieve your latest generated videos using the CLI:

```bash
# Retrieve the most recently generated video link
vibiz files latest --type video

# Search files by prompt
vibiz files search "ocean waves"
```

## Controlling spend and setting hard limits

Because video generation costs more per call than standard text prompts, setting spending limits protects your project against runaway costs from loops or automated agents:

1. **Account daily spend ceiling**: Set to $5 per account per UTC day by default across all AI and actions combined. An owner can raise this in Billing. Each call is held at its worst-case cost before running. If a call cannot fit in your balance plus $0.50, it fails with `402 payment_required`.
2. **Project budget ceiling**: Set to $1 per project per UTC day by default. You can adjust this through the CLI or API:
   ```bash
   vibiz ai budget 25.00 --project prj_123
   ```
   Or via the API:
   ```bash
   curl -X PATCH https://thelastapi.dev/v1/projects/prj_123/ai \
     -H "Authorization: Bearer $VIBIZ_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"daily_budget_usd": 25.00, "end_user_daily_budget_usd": 5.00}'
   ```
3. **End-user tracking**: Pass your application's user ID via the `user` field in JSON or through the `X-Vibiz-User` HTTP header. This breaks down spend per end user and enforces `end_user_daily_budget_usd`.
4. **Single-call caps**: Any individual media call running an external model by ID is capped at $10. Calls exceeding this threshold fail with `call_too_expensive`.
5. **Rate limits**: A project key supports 120 requests per minute and up to 25 concurrent in-flight requests (configurable up to 50); a call over that waits up to 60 s for a free slot instead of failing.

If a project exceeds its budget, the API returns HTTP `429` with `details.reason: "project_budget"`. Daily limits reset at midnight UTC. For broader cost modeling across language and multimodal features, review [how much does it cost to add GPT to a SaaS app?](https://thelastapi.dev/blog/cost-to-add-gpt-to-saas).

Read the complete parameter reference and model catalogue in the [AI docs](https://thelastapi.dev/docs/ai). Create your account at [thelastapi.dev/start](https://thelastapi.dev/start) to get your key.

## Frequently asked questions

### How much does a video cost if I use the default vibiz/video model?

Each video costs $0.54 and produces a six-second clip at 720p with sound, which works out to $0.09 per second.

### How long do generated video download links remain active?

Video links generated within a project are saved permanently in project Files and do not expire. If you generate a video using an account key without specifying a project, the link expires after 24 hours.

### What happens if an API call exceeds the daily budget while generating video?

The API rejects the call before processing with HTTP status 429 and `details.reason: "project_budget"`, preventing unexpected overages.

### What aspect ratios are supported for video generation?

The API supports `16:9` and `9:16`. Requests specifying `1:1` are automatically returned as `16:9`.

---

Published 2026-11-15 · https://thelastapi.dev/blog/ai-video-api-cost-per-clip
