> ## Documentation Index
> Fetch the complete documentation index at: https://docs.apipod.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Kling 3.0 Turbo Text to Video

> Kling 3.0 Turbo T2V is APIPod's text-to-video mode for Kling 3.0 Turbo, the faster Kling 3.0 tier that always generates native audio and supports multi-shot prompts.

## Usage notes

* **Multi-shot**: describe up to 6 shots in `multi_prompt` (`{prompt, duration}`, up to 512 characters each). Shot durations must add up to exactly `duration` (3-15 seconds). `multi_shot` is not accepted.
* **Audio**: native audio is always generated; `generate_audio: false` is rejected.
* **Not supported**: `negative_prompt` (write exclusions into the prompt), `audio_urls`, and `video_url` (use `video_urls`).

## Billing

Billed per second of output video. The per-second rate depends on the resolution (720p or 1080p); native audio is always included. Current prices are shown on the [model page](https://www.apipod.ai/models).

## Task flow

The create call returns `data.task_id`. Poll [Query video task](/query-video-task) until `status` is `completed` (outputs in `data.result`) or `failed`, or pass `callback_url` to be notified when the task reaches a terminal state.


## OpenAPI

````yaml api-reference/openapi/kling-3.0--kling-3.0-turbo-t2v.yaml POST /v1/videos/generations
openapi: 3.1.0
info:
  title: Kling 3.0 Turbo Text to Video API
  version: 1.0.0
  description: >-
    Kling 3.0 Turbo T2V is APIPod's text-to-video mode for Kling 3.0 Turbo, the
    faster Kling 3.0 tier that always generates native audio and supports
    multi-shot prompts. In APIPod, the public model ID is kling-3.0-turbo-t2v.
    It accepts text input and returns results through asynchronous video tasks.
servers:
  - url: https://api.apipod.ai
    description: Production
security: []
paths:
  /v1/videos/generations:
    post:
      tags:
        - Kling 3.0 Turbo Text to Video
      summary: Create Generation Task
      description: >-
        Kling 3.0 Turbo T2V is APIPod's text-to-video mode for Kling 3.0 Turbo,
        the faster Kling 3.0 tier that always generates native audio and
        supports multi-shot prompts. In APIPod, the public model ID is
        kling-3.0-turbo-t2v. It accepts text input and returns results through
        asynchronous video tasks.
      operationId: create-kling-3.0-kling-3.0-turbo-t2v
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              title: Kling 3.0 Turbo Text to Video
              properties:
                model:
                  type: string
                  title: Model ID
                  description: Public APIPod model ID.
                  const: kling-3.0-turbo-t2v
                prompt:
                  type: string
                  title: Prompt
                  description: >-
                    Text prompt, up to 2,500 characters. Required unless
                    `multi_prompt` is provided.
                  maxLength: 2500
                duration:
                  type: integer
                  title: Duration
                  description: >-
                    Output duration in seconds (3-15). Defaults to 5. With
                    `multi_prompt`, the shot durations must add up to exactly
                    this value; when omitted it defaults to the sum of the shot
                    durations.
                  minimum: 3
                  maximum: 15
                  default: 5
                resolution:
                  type: string
                  title: Resolution
                  description: >-
                    Output resolution. Defaults to 720p. The per-second rate
                    depends on the resolution.
                  enum:
                    - 720p
                    - 1080p
                  default: 720p
                aspect_ratio:
                  type: string
                  title: Aspect Ratio
                  description: Output aspect ratio. Defaults to 16:9.
                  enum:
                    - '16:9'
                    - '9:16'
                    - '1:1'
                  default: '16:9'
                multi_prompt:
                  type: array
                  title: Multi Prompt
                  description: >-
                    Shot list for multi-shot generation, up to 6 shots. Each
                    shot is `{prompt, duration}` with a prompt of up to 512
                    characters; the shot durations must add up to `duration`
                    (3-15 seconds).
                  maxItems: 6
                  items:
                    type: object
                    properties:
                      prompt:
                        type: string
                        description: Shot description, up to 512 characters.
                        maxLength: 512
                      duration:
                        type: integer
                        description: Shot duration in seconds (1-15).
                        minimum: 1
                        maximum: 15
                    required:
                      - prompt
                      - duration
                watermark:
                  type: boolean
                  title: Watermark
                  description: >-
                    When true, an additional watermarked copy is generated and
                    the watermarked copy is returned as the result.
                  default: false
                callback_url:
                  type: string
                  title: Callback URL
                  description: HTTPS URL that receives the task's terminal state.
                  default: ''
              required:
                - model
            examples:
              basic:
                summary: Single shot
                value:
                  model: kling-3.0-turbo-t2v
                  prompt: >-
                    A street drummer performs in the rain at night, crowd
                    cheering, handheld camera.
                  duration: 5
                  resolution: 720p
                  aspect_ratio: '16:9'
              multi_shot:
                summary: Multi-shot with multi_prompt
                value:
                  model: kling-3.0-turbo-t2v
                  multi_prompt:
                    - prompt: >-
                        Wide shot: a lighthouse on a rocky cliff at dawn, waves
                        crashing below.
                      duration: 2
                    - prompt: >-
                        Medium shot: the keeper climbs the spiral staircase
                        holding a lantern.
                      duration: 3
                    - prompt: >-
                        Close-up: the lamp turns on and sweeps light across the
                        fog.
                      duration: 3
                  duration: 8
                  resolution: 1080p
                  aspect_ratio: '16:9'
      responses:
        '200':
          description: Task accepted
          content:
            application/json:
              schema:
                type: object
                title: Task Submit Response
                description: Standard response for task submission
                properties:
                  code:
                    type: integer
                  data:
                    type: object
                    title: Task Submit Data
                    description: Data content for task submission
                    properties:
                      task_id:
                        type: string
                        description: Task ID used to query the task status.
                  message:
                    type: string
                required:
                  - code
                  - message
                  - data
              example:
                code: 200
                message: success
                data:
                  task_id: vid_task_01JEXAMPLE
      security:
        - bearerAuth: []
      x-codeSamples:
        - lang: Shell
          label: cURL
          source: |-
            curl https://api.apipod.ai/v1/videos/generations \
              -H "Authorization: Bearer $APIPOD_API_KEY" \
              -H "Content-Type: application/json" \
              -d '{
              "model": "kling-3.0-turbo-t2v",
              "prompt": "A street drummer performs in the rain at night, crowd cheering, handheld camera.",
              "duration": 5,
              "resolution": "720p",
              "aspect_ratio": "16:9"
            }'
        - lang: Python
          label: Python
          source: |-
            import os
            import requests

            payload = {
              "model": "kling-3.0-turbo-t2v",
              "prompt": "A street drummer performs in the rain at night, crowd cheering, handheld camera.",
              "duration": 5,
              "resolution": "720p",
              "aspect_ratio": "16:9"
            }

            response = requests.post(
                "https://api.apipod.ai/v1/videos/generations",
                headers={
                    "Authorization": f"Bearer {os.environ['APIPOD_API_KEY']}",
                    "Content-Type": "application/json",
                },
                json=payload,
                timeout=60,
            )
            response.raise_for_status()
            print(response.json())
        - lang: Go
          label: Go
          source: |-
            package main

            import (
                "bytes"
                "fmt"
                "io"
                "net/http"
                "os"
            )

            func main() {
                body := []byte(`{
              "model": "kling-3.0-turbo-t2v",
              "prompt": "A street drummer performs in the rain at night, crowd cheering, handheld camera.",
              "duration": 5,
              "resolution": "720p",
              "aspect_ratio": "16:9"
            }`)

                req, err := http.NewRequest(http.MethodPost, "https://api.apipod.ai/v1/videos/generations", bytes.NewReader(body))
                if err != nil {
                    panic(err)
                }
                req.Header.Set("Authorization", "Bearer "+os.Getenv("APIPOD_API_KEY"))
                req.Header.Set("Content-Type", "application/json")

                resp, err := http.DefaultClient.Do(req)
                if err != nil {
                    panic(err)
                }
                defer resp.Body.Close()
                out, _ := io.ReadAll(resp.Body)
                fmt.Println(resp.Status, string(out))
            }
        - lang: Rust
          label: Rust
          source: |-
            use reqwest::Client;
            use serde_json::json;
            use std::env;

            #[tokio::main]
            async fn main() -> Result<(), Box<dyn std::error::Error>> {
                let payload = json!({
                  "model": "kling-3.0-turbo-t2v",
                  "prompt": "A street drummer performs in the rain at night, crowd cheering, handheld camera.",
                  "duration": 5,
                  "resolution": "720p",
                  "aspect_ratio": "16:9"
                });
                let response = Client::new()
                    .post("https://api.apipod.ai/v1/videos/generations")
                    .bearer_auth(env::var("APIPOD_API_KEY")?)
                    .json(&payload)
                    .send()
                    .await?
                    .error_for_status()?;

                println!("{}", response.text().await?);
                Ok(())
            }
        - lang: JavaScript
          label: JavaScript
          source: >-
            const response = await
            fetch("https://api.apipod.ai/v1/videos/generations", {
              method: "POST",
              headers: {
                Authorization: `Bearer ${process.env.APIPOD_API_KEY}`,
                "Content-Type": "application/json",
              },
              body: JSON.stringify({
                "model": "kling-3.0-turbo-t2v",
                "prompt": "A street drummer performs in the rain at night, crowd cheering, handheld camera.",
                "duration": 5,
                "resolution": "720p",
                "aspect_ratio": "16:9"
              }),
            });


            if (!response.ok) {
              throw new Error(`APIPod request failed: ${response.status} ${await response.text()}`);
            }


            console.log(await response.json());
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: APIPod API key
      description: Use your APIPod API key as a Bearer token in the Authorization header.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.