Name: Kling O1 Video Generation and Editing API
Brand: magicapi
SKU: api-magicapi-video-modification-natural-language-commands-kwaivgi-kling-o1
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 Video Generation and Editing API (Kling O1)

## Overview

Kling O1, from Kuaishou, generates and edits video from a text prompt. Kuaishou describes it as a way to modify an existing video through natural-language commands, changing subjects, environments and visual style while preserving the original motion and timing.

The same endpoint also covers generation: text to video, image to video with a first and optional last frame, reference images for elements, scenes or styles, and a reference video used as a style and camera-movement reference. Inputs are referenced in the prompt with tags such as `<<<image_1>>>` and `<<<video_1>>>`.

## Features

- **Video editing with text commands**: Set `reference_video` with `video_reference_type: "base"` and describe the change in `prompt`.
- **Style and camera reference**: `reference_video` with `video_reference_type: "feature"` (default) uses the video for style or camera movement.
- **Text to video**: `prompt` plus `aspect_ratio` (`16:9`, `9:16`, `1:1`).
- **Image to video**: `start_image` sets the first frame; `end_image` sets the last frame and requires `start_image`. `.jpg`, `.jpeg` or `.png`, up to 10 MB.
- **Reference images**: `reference_images` for elements, scenes or styles, up to 7 without a video or 4 with a video.
- **Two quality modes**: `std` (cost-effective) and `pro` (higher quality, the default).
- **Keep the original sound**: `keep_original_sound` (default true) keeps the reference video's audio.

## Use Cases

- **Restyling footage**: Change the look, setting or subject of an existing clip while keeping its motion.
- **Product and ad videos**: Animate a product photo from a first frame, or between a first and last frame.
- **Consistent characters and scenes**: Use reference images to keep elements the same across clips.
- **Matching a camera move**: Use a reference video to copy its style or camera movement in a new scene.

## Visual Examples

The example below is a text-to-video request in `std` mode.

- **Prompt**: "A small robot waters plants on a sunny balcony"
- **Mode**: `std`
- **Duration**: 5 seconds

Output:

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

## Pricing

- **Pay As You Go (PAYG) pricing**: You only pay for what you use.
- **Price**: $0.105 per API unit.
- **Billing is per second of output video.** Each second counts as a number of units that depends on the mode and whether you send a `reference_video`:
  - **`std` mode**: 1 unit per second, $0.105 per second.
  - **`pro` mode** (the default): 1.334 units per second, about $0.1401 per second.
  - **`std` mode with a `reference_video`**: 1.5 units per second, $0.1575 per second.
  - **`pro` mode with a `reference_video`**: 2 units per second, $0.21 per second.
- **The total for a request is rounded up to a whole unit.**
- **Worked examples for a 5 second clip**:
  - `std`: 5 units, **$0.525** (this is the example above).
  - `pro`: 5 x 1.334 = 6.67, rounded up to 7 units, **$0.735**.
  - `std` with a reference video: 5 x 1.5 = 7.5, rounded up to 8 units, **$0.84**.
  - `pro` with a reference video: 5 x 2 = 10 units, **$1.05**.
- **Video editing** (`video_reference_type: "base"`) ignores `duration`, so it is billed on the length of the video returned.
- **Failed or cancelled predictions**: Not billed.
- **GET requests to check prediction status**: Free and don't count toward API unit usage.
- **No monthly subscription fee**: Pay as you go.

## API Documentation

### Base URL

All API requests go to: `https://prod.api.market/api/v1/magicapi/video-modification-natural-language-commands-kwaivgi-kling-o1`

### Authentication

Include your api.market API key in the `x-api-market-key` header of every request:

```http
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing

This API is asynchronous:

1. Send a POST request to `/predictions`. The response is **201 Created** with a prediction `id` and a `status` of `starting` or `processing`. A 201 means the job was accepted; it is not an error.
2. Poll GET `/predictions/{id}` (for example once a second).
3. Stop when `status` is `succeeded` (the result is in `output`), `failed` or `canceled` (details in `error`).

Set a client-side timeout (for example 10 minutes) so a stuck job does not poll forever.

### Endpoints

#### POST /predictions

Creates a prediction. This is the request used for the example above:

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/video-modification-natural-language-commands-kwaivgi-kling-o1/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  --data @- <<'EOF'
{
  "version": "6d5f2d4becc7f734d190d17f13f776229c359cafc1c1898d78945e8d87c57538",
  "input": {
    "prompt": "A small robot waters plants on a sunny balcony",
    "mode": "std",
    "duration": 5
  }
}
EOF
```

**Response (201 Created):**

```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "6d5f2d4becc7f734d190d17f13f776229c359cafc1c1898d78945e8d87c57538",
  "status": "starting",
  "created_at": "2026-10-13T10:45:20.695Z"
}
```

#### GET /predictions/{id}

Returns the prediction's status and, once it has succeeded, its output.

```bash
curl "https://prod.api.market/api/v1/magicapi/video-modification-natural-language-commands-kwaivgi-kling-o1/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Response (200 OK, succeeded):**

```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/kling-o1-output-api-market.mp4",
  "created_at": "2026-10-13T10:45:20.695Z",
  "started_at": "2026-10-13T10:45:21.102Z",
  "completed_at": "2026-10-13T10:46:05.480Z"
}
```

`output` is a single URL to the generated MP4 video.

### Input Parameters

| Parameter | Type | Default | Required | Description |
|---|---|---|---|---|
| `prompt` | string | - | Yes | Text prompt for video generation. Can include references like `<<<image_1>>>`, `<<<video_1>>>` to reference inputs. |
| `start_image` | string (URI) | - | No | First frame image for the video. Supports .jpg/.jpeg/.png, max 10MB. |
| `end_image` | string (URI) | - | No | Last frame image for the video. Requires start_image to be set. Supports .jpg/.jpeg/.png, max 10MB. |
| `reference_images` | array of string (URI) | - | No | Reference images for elements, scenes, or styles (up to 7 without video, 4 with video). Supports .jpg/.jpeg/.png. |
| `reference_video` | string (URI) | - | No | Reference video for style, camera movement, or as base for editing. Supports .mp4/.mov, 3-10s duration, max 200MB. |
| `video_reference_type` | string | feature | No | How to use the reference video: 'feature' for style/camera reference, 'base' for video editing. Allowed values: `feature`, `base`. |
| `keep_original_sound` | boolean | true | No | Whether to keep the original sound from the reference video. |
| `mode` | string | pro | No | Video generation mode. 'std' is cost-effective, 'pro' has higher quality. Allowed values: `std`, `pro`. |
| `aspect_ratio` | string | 16:9 | No | Aspect ratio of the generated video. Required for text-to-video. Ignored when using first frame image or video editing. Allowed values: `16:9`, `9:16`, `1:1`. |
| `duration` | integer | 5 | No | Video duration in seconds. For text/image-to-video: 5 or 10. With video reference (feature type): 3-10. Ignored for video editing (base type). Allowed values: `3`, `4`, `5`, `6`, `7`, `8`, `9`, `10`. |

How the inputs combine:

- **Text to video**: `prompt`, `aspect_ratio`, `duration` of 5 or 10.
- **Image to video**: `start_image` (and optionally `end_image`); `aspect_ratio` is ignored.
- **Video reference** (`video_reference_type: "feature"`): `duration` from 3 to 10.
- **Video editing** (`video_reference_type: "base"`): `duration` and `aspect_ratio` are ignored.
- `reference_video` must be `.mp4` or `.mov`, 3 to 10 seconds, up to 200 MB.

### Status Codes

- **201 Created**: Prediction accepted (POST). Poll the GET endpoint for the result.
- **200 OK**: Prediction returned (GET).
- **400 Bad Request**: Invalid input, for example a value outside the allowed range or enum.
- **401 Unauthorized**: Missing or invalid `x-api-market-key`.
- **404 Not Found**: Unknown prediction ID.
- **429 Too Many Requests**: Too many requests in a short time. Wait and retry.
- **500 Internal Server Error**: Server-side error. Retry later.

### Error Handling

- Treat both 200 and 201 as success.
- A prediction can still end with `status: "failed"`; read the `error` field for the reason. Failed predictions are not billed.
- Retry 429 and 5xx responses with exponential backoff. Fix the request before retrying a 400.

## 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

### JavaScript

```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/video-modification-natural-language-commands-kwaivgi-kling-o1";

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

  // 201 Created is the normal success response here.
  if (!response.ok) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

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

async function pollForResult(id) {
  const timeoutMs = 10 * 60 * 1000;
  const start = Date.now();

  while (Date.now() - start < timeoutMs) {
    const response = await fetch(`${baseUrl}/predictions/${id}`, {
      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 new Promise((resolve) => setTimeout(resolve, 1000));
  }

  throw new Error("Prediction timed out");
}

createAndWaitForPrediction({
  "prompt": "A small robot waters plants on a sunny balcony",
  "mode": "std",
  "duration": 5
}).then(console.log);
```

### Python

```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/video-modification-natural-language-commands-kwaivgi-kling-o1"

def create_and_wait_for_prediction(input_data):
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers={"Content-Type": "application/json", "x-api-market-key": API_KEY},
        json={"version": "6d5f2d4becc7f734d190d17f13f776229c359cafc1c1898d78945e8d87c57538", "input": input_data},
    )
    # 201 Created is the normal success response here.
    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")
    return poll_for_result(response.json()["id"])

def poll_for_result(prediction_id, timeout=600):
    start = time.time()
    while time.time() - start < timeout:
        response = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers={"x-api-market-key": API_KEY},
        )
        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"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'unknown error'}")
        time.sleep(1)
    raise Exception("Prediction timed out")

print(create_and_wait_for_prediction({
  "prompt": "A small robot waters plants on a sunny balcony",
  "mode": "std",
  "duration": 5
}))
```

### cURL

```bash
# Step 1: create the prediction (returns 201 Created with an id)
curl -X POST "https://prod.api.market/api/v1/magicapi/video-modification-natural-language-commands-kwaivgi-kling-o1/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  --data @- <<'EOF'
{
  "version": "6d5f2d4becc7f734d190d17f13f776229c359cafc1c1898d78945e8d87c57538",
  "input": {
    "prompt": "A small robot waters plants on a sunny balcony",
    "mode": "std",
    "duration": 5
  }
}
EOF

# Step 2: poll with the id from step 1 until status is succeeded, failed or canceled
curl "https://prod.api.market/api/v1/magicapi/video-modification-natural-language-commands-kwaivgi-kling-o1/predictions/PREDICTION_ID" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

## FAQ

**Why do I get a 201 response instead of the result?**
The API is asynchronous. 201 Created means the prediction was accepted. Poll GET `/predictions/{id}` until `status` is `succeeded` and read `output`.

**How do I edit an existing video?**
Send the video as `reference_video`, set `video_reference_type` to `base`, and describe the change in `prompt` (you can refer to the video as `<<<video_1>>>`).

**What is the difference between std and pro?**
`std` is the cost-effective mode and `pro` (the default) has higher quality. Pro costs 1.334 units per second instead of 1.

**Which durations can I use?**
5 or 10 seconds for text or image to video, 3 to 10 seconds with a video reference. Video editing ignores `duration`.

**How many reference images can I send?**
Up to 7 without a reference video, or up to 4 with one.

## 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 images, or edit an existing clip with a text command, using Kling O1. Standard and pro modes, pay per second.

Kling O1 Video Generation and Editing API