Name: Cinematic Text and Image-to-Video API (Kling 2.6)
Brand: magicapi
SKU: api-magicapi-image-to-video-cinematic-generation-kwaivgi-kling-v2-6
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 Cinematic Text and Image-to-Video API (Kling 2.6)

## Overview
This API generates video with Kling 2.6 Pro from Kuaishou, a model built for cinematic visuals, fluid motion and native audio generation. Describe the scene in a `prompt`, optionally give a `start_image` to use as the first frame, and choose a 5 or 10 second clip. By default the model also creates synchronized audio based on the video content. The response is a URL to the generated video.

## Features
- **Text-to-video**: `prompt` is the only required field.
- **Image-to-video**: pass `start_image` to set the first frame of the video.
- **Native audio**: `generate_audio` (default `true`) creates synchronized audio based on the video content. Set it to `false` for a silent video at half the price.
- **Duration**: `5` (default) or `10` seconds.
- **Aspect ratio**: `16:9` (default), `9:16` or `1:1`. Ignored when `start_image` is provided.
- **Negative prompt**: list things you do not want to see in the video.

## Use Cases
1. **Ads and social clips**: Produce short scenes with matching sound for campaigns and social posts.
2. **Animating key visuals**: Start from a product shot or artwork with `start_image` and add camera movement and action.
3. **Storyboards and concept films**: Draft scenes, moods and camera moves from written descriptions.
4. **Video with ambient sound**: Generate scenes where the audio (rain, music, crowd noise) is created together with the picture.

## Visual Examples
### Example Input
**Prompt:**
`A street musician plays a saxophone under a streetlight on a rainy night, warm light, the sound of the saxophone and light rain`

**Settings:** all other fields at their defaults (5 seconds, 16:9, `generate_audio` on). No start image was used.

### Example Output
[Watch the example video](https://blog.api.market/wp-content/uploads/2026/10/kling-v2.6-output-api-market.mp4)

## Pricing
- **Pay As You Go (PAYG)**: you only pay for what you use.
- **Price**: $0.088 per API unit.
- **Billing unit**: per second of output video. The number of seconds is multiplied by the audio tier:
  - **Without audio** (`generate_audio` false): 1 unit per second = **$0.088 per second**
  - **With audio** (`generate_audio` true, the default): 2 units per second = **$0.176 per second**
- Per video:
  - 5 seconds with audio (the default, and the example on this page): 10 units = $0.88
  - 10 seconds with audio: 20 units = $1.76
  - 5 seconds without audio: 5 units = $0.44
  - 10 seconds without audio: 10 units = $0.88
- Failed or cancelled predictions are not billed.
- GET requests to check prediction status are free and don't count toward API unit usage.
- No monthly subscription fee.

## API Documentation

### Base URL
All API requests should be made to:
`https://prod.api.market/api/v1/magicapi/image-to-video-cinematic-generation-kwaivgi-kling-v2-6`

### Authentication
Include your api.market API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. Follow these steps:
1. Send a POST request to `/predictions` with the `version` and your `input`.
2. The API answers **201 Created** with a prediction `id` and a `status` of `starting` or `processing`. A 201 response means the job was accepted; it is not an error.
3. Poll GET `/predictions/{id}` with that ID.
4. Stop when `status` is `succeeded`, `failed` or `canceled`. On `succeeded`, `output` holds the URL of the generated video.

Video generation is not instant. The code samples below poll once per second and give up after 600 seconds (10 minutes); raise the timeout if your requests take longer.

### Endpoints

#### POST /api/v1/magicapi/image-to-video-cinematic-generation-kwaivgi-kling-v2-6/predictions
Create a prediction. This is the request used for the example on this page:

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/image-to-video-cinematic-generation-kwaivgi-kling-v2-6/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "b13f36d030496dd78d2986ba8b2b22a44222b3f58c15fb63ef7d6b4aa3a53319",
    "input": {
      "prompt": "A street musician plays a saxophone under a streetlight on a rainy night, warm light, the sound of the saxophone and light rain"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "b13f36d030496dd78d2986ba8b2b22a44222b3f58c15fb63ef7d6b4aa3a53319",
  "status": "starting",
  "created_at": "2026-10-11T19:15:11.521Z"
}
```

#### GET /api/v1/magicapi/image-to-video-cinematic-generation-kwaivgi-kling-v2-6/predictions/{id}
Check the status of a prediction and get its output. Status checks are free.

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/image-to-video-cinematic-generation-kwaivgi-kling-v2-6/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "b13f36d030496dd78d2986ba8b2b22a44222b3f58c15fb63ef7d6b4aa3a53319",
  "status": "succeeded",
  "input": {
    "prompt": "A street musician plays a saxophone under a streetlight on a rainy night, warm light, the sound of the saxophone and light rain"
  },
  "output": "https://blog.api.market/wp-content/uploads/2026/10/kling-v2.6-output-api-market.mp4",
  "error": null,
  "created_at": "2026-10-11T19:15:11.521Z",
  "started_at": "2026-10-11T19:15:12.104Z",
  "completed_at": "2026-10-11T19:16:20.733Z"
}
```

### Input Parameters
| Parameter | Type | Default | Required | Description |
|---|---|---|---|---|
| `prompt` | string | - | yes | Text prompt for video generation. |
| `negative_prompt` | string | `""` | no | Things you do not want to see in the video. |
| `start_image` | string | - | no | First frame of the video. |
| `aspect_ratio` | string | `16:9` | no | Aspect ratio of the video. Ignored if start_image is provided. One of: `16:9`, `9:16`, `1:1`. |
| `duration` | integer | `5` | no | Duration of the video in seconds. One of: `5`, `10`. |
| `generate_audio` | boolean | `true` | no | Generate audio for the video. When enabled, the model will create synchronized audio based on the video content. |

### Status Codes
- **201 Created**: The POST request was accepted and the prediction was created (success). Poll the GET endpoint for the result.
- **200 OK**: The GET request succeeded. Check the `status` field to see whether the prediction has finished.
- **400 Bad Request**: Invalid input parameters or malformed request
- **401 Unauthorized**: Missing or invalid API key
- **404 Not Found**: Prediction not found
- **429 Too Many Requests**: Rate limit exceeded
- **500 Internal Server Error**: Server-side error

### Error Handling
1. **HTTP errors**: Read the response body for the error message. Fix the request for `400` and `401`; retry `429` and `5xx` with exponential backoff.
2. **Failed predictions**: If GET returns `status: "failed"`, the `error` field explains why. Failed and cancelled predictions are not billed.
3. **Timeouts**: If a prediction is still `starting` or `processing` when your timeout runs out, you can keep polling the same ID later.

### Rate Limits

All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.

## Implementation Guide
### Example Code
#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/image-to-video-cinematic-generation-kwaivgi-kling-v2-6";

async function createAndWaitForPrediction(inputData) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "b13f36d030496dd78d2986ba8b2b22a44222b3f58c15fb63ef7d6b4aa3a53319", input: inputData })
  });

  // 201 Created means the prediction was accepted
  if (!response.ok) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return await pollForResults(prediction.id);
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function pollForResults(predictionId) {
  const MAX_TIMEOUT = 600000; // 600 seconds (10 minutes)
  const POLL_INTERVAL = 1000; // 1 second between checks
  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(POLL_INTERVAL);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

createAndWaitForPrediction({
  "prompt": "A street musician plays a saxophone under a streetlight on a rainy night, warm light, the sound of the saxophone and light rain"
}).then(output => console.log(output));
```

#### Python
```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/image-to-video-cinematic-generation-kwaivgi-kling-v2-6"

def create_and_wait_for_prediction(input_data):
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }

    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "b13f36d030496dd78d2986ba8b2b22a44222b3f58c15fb63ef7d6b4aa3a53319", "input": input_data}
    )

    # 201 Created means the prediction was accepted
    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")

    prediction = response.json()
    return poll_for_results(prediction["id"])

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # 600 seconds (10 minutes)
    POLL_INTERVAL = 1  # 1 second between checks

    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < MAX_TIMEOUT:
        response = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers=headers
        )

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            error_msg = prediction.get("error") or "Unknown error"
            raise Exception(f"Prediction {prediction['status']}: {error_msg}")

        time.sleep(POLL_INTERVAL)

    raise Exception("Prediction timed out after 10 minutes")

output = create_and_wait_for_prediction({
  "prompt": "A street musician plays a saxophone under a streetlight on a rainy night, warm light, the sound of the saxophone and light rain"
})
print(output)
```

#### cURL
```bash
# Step 1: Create a prediction (returns 201 Created)
curl -X POST "https://prod.api.market/api/v1/magicapi/image-to-video-cinematic-generation-kwaivgi-kling-v2-6/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "b13f36d030496dd78d2986ba8b2b22a44222b3f58c15fb63ef7d6b4aa3a53319",
    "input": {
      "prompt": "A street musician plays a saxophone under a streetlight on a rainy night, warm light, the sound of the saxophone and light rain"
    }
  }'

# The response contains a prediction ID, for example:
# {"id": "ufawqhfynnddngldkgtslldrkq", "status": "starting", ...}

# Step 2: Check the prediction status (replace the ID with yours)
curl -X GET "https://prod.api.market/api/v1/magicapi/image-to-video-cinematic-generation-kwaivgi-kling-v2-6/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Repeat step 2 until status is "succeeded", "failed" or "canceled"
```

### Performance Optimization
- Set `generate_audio` to `false` when you will add your own soundtrack; it halves the price.
- Use 5 second clips while iterating on a prompt, then switch to 10 seconds for the final version.
- Use `negative_prompt` to steer away from unwanted elements instead of rewriting the whole prompt.

## FAQ
1. **Do I need an image?**
   - No. `prompt` is the only required field. Add `start_image` if you want the video to begin from a specific frame.

2. **Does the video include sound?**
   - Yes by default. `generate_audio` is `true` unless you set it to `false`, and the price depends on it (see Pricing).

3. **How long are the videos?**
   - 5 or 10 seconds, set with `duration`.

4. **Which aspect ratios are supported?**
   - `16:9`, `9:16` and `1:1`. When you pass `start_image`, the aspect ratio setting is ignored.

5. **How do I handle failures?**
   - Check the `status` field. If it is `failed` or `canceled`, read the `error` field. Failed and cancelled predictions are not billed.

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.


Create 5 or 10 second videos from text or a start image with Kling 2.6 Pro, with optional synchronized audio. Pay per second of video.