Name: Text-to-Video & Image-to-Video API - Kling 2.5 Turbo Pro
Brand: magicapi
SKU: api-magicapi-text-to-video-image-to-video-api-kwaivgi-kling-v2-5-turbo-pro
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 Pro-Level Text-to-Video & Image-to-Video API (Kling 2.5 Turbo Pro)

## Overview
The Kling 2.5 Turbo Pro API enables developers to create professional-level videos with smooth motion and cinematic depth from text descriptions and images. This API excels at prompt adherence, ensuring generated videos match the given descriptions or images accurately.

## Features
- **Text-to-Video Generation**: Create videos from detailed text descriptions.
- **Image-to-Video Generation**: Generate videos from provided start and end images.
- **Smooth Motion**: Videos exhibit fluid and seamless motion.
- **Cinematic Depth**: Tuned for cinematic camera motion and depth.
- **Remarkable Prompt Adherence**: Ensures generated content closely matches input prompts.

## Use Cases
1. **Marketing Campaigns**: Create engaging video ads by providing a text prompt without the need for lengthy video shoots.
2. **Content Creation**: Streamline the production of high-quality video content for social media influencers and digital creators by converting written ideas into engaging visual content.
3. **Educational Resources**: Generate explanatory videos from text descriptions to enhance learning materials and online courses.
4. **Entertainment Industry**: Facilitate the creation of cinematic scenes with minimal effort for indie filmmakers and game developers.
5. **Product Promotions**: Allow e-commerce websites to showcase products in dynamic videos derived from textual descriptions or static images.

## Visual Examples

### Example Input

```json
{
  "input": {
    "prompt": "a woman is dancing in a bright studio, full body visible, smooth graceful movements",
    "duration": 5,
    "aspect_ratio": "16:9"
  }
}
```

### Example Output

![Example output from Pro-Level Text-to-Video & Image-to-Video API (Kling 2.5 Turbo Pro)](https://blog.api.market/wp-content/uploads/2026/09/kling-v2-5-turbo-pro-output-api-market.mp4)

This exact request was run through api.market and billed 5 API units ($0.44).
## Pricing
- **Pay As You Go (PAYG) pricing**: You only pay for what you use.
- **Price**: $0.088 per API unit.
- **1 API unit** = 1 second of output video, rounded up to whole seconds. The seconds are measured on the returned video, so a clip whose length is set by an input audio or video bills its actual length.
- **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/text-to-video-image-to-video-api-kwaivgi-kling-v2-5-turbo-pro`

### Authentication
Authentication is handled via API key. Include your API key in the request header:

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

### Asynchronous Processing

**IMPORTANT**: This API uses asynchronous processing for predictions. The typical flow is:

1. Submit a prediction request to the POST endpoint
2. Receive a prediction ID in the response
3. Poll the GET endpoint with the prediction ID to check status
4. Continue polling until the prediction is complete

The processing time varies depending on the complexity of the request. Your code should implement:
- A polling interval of 1 second between status checks
- A maximum timeout of 600 seconds (10 minutes)
- Status checking logic that continues while status is "starting" or "processing"
- Result handling when status becomes "succeeded"
- Error handling when status becomes "failed" or timeout is reached

See the Implementation Guide section for code examples.

### Input Parameters

| Name | Type | Required | Default | Allowed values and notes |
|---|---|---|---|---|
| `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 (URL) | No |  | First frame of the video (image-to-video) |
| `end_image` | string (URL) | No |  | Last frame of the video |
| `aspect_ratio` | string | No | "16:9" | "16:9", "9:16" or "1:1"; ignored if `start_image` is provided |
| `duration` | integer | No | 5 | 5 or 10 (seconds) |
| `image` | string (URL) | No |  | Deprecated; use `start_image` |
| `guidance_scale` | number | No |  | Deprecated; not used |

### Endpoints

#### Create a Prediction (POST /predictions)
Submit a prediction request.

```bash
# Example for creating a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-video-image-to-video-api-kwaivgi-kling-v2-5-turbo-pro/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "a3ccc39250a72749ced345996ec06d96d1d032b1a1369f45f3b9f654324036b5",
    "input": {
      "prompt": "a woman is dancing in a bright studio, full body visible, smooth graceful movements in a bright studio, full body visible, smooth graceful movements",
      "duration": 5,
      "aspect_ratio": "16:9"
    }
  }'
```

#### Check Prediction Status (GET /predictions/{id})
Poll for prediction status using the ID received from the POST endpoint.

```bash
# Example for checking prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-video-image-to-video-api-kwaivgi-kling-v2-5-turbo-pro/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Status Codes
- **200 OK**: Request successful
- **201 Created**: Resource successfully created
- **400 Bad Request**: Invalid input parameters or malformed request
- **401 Unauthorized**: Missing or invalid API key
- **403 Forbidden**: Valid API key but insufficient permissions
- **404 Not Found**: Resource not found
- **429 Too Many Requests**: Rate limit exceeded
- **500 Internal Server Error**: Server-side error
- **503 Service Unavailable**: Service temporarily unavailable

### Rate Limits
If you receive a 429 Too Many Requests response, wait and retry with exponential backoff.

### Error Handling
- A 400 response means the request was rejected; check input names and values against the Input Parameters table.
- A prediction that ends with status "failed" includes an `error` message. Failed predictions are not billed.
- For 429, 500 and 503 responses, retry with exponential backoff.

#### Error Response Example

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'prompt' is required",
    "status": 400
  }
}
```

### Implementation Guide

#### Example Code

##### JavaScript
```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/text-to-video-image-to-video-api-kwaivgi-kling-v2-5-turbo-pro";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey
      },
      body: JSON.stringify({ version: "a3ccc39250a72749ced345996ec06d96d1d032b1a1369f45f3b9f654324036b5", input: inputData })
    });
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }
    
    const prediction = await response.json();
    const predictionId = prediction.id;
    
    // Step 2: Poll for results with timeout
    return await pollForResults(predictionId);
  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}

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) {
    // Check prediction status
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: {
        "x-api-market-key": apiKey
      }
    });
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }
    
    const prediction = await response.json();
    
    // Check status and return if completed
    if (prediction.status === "succeeded") {
      return prediction.output;
    }
    
    // Handle failure
    if (prediction.status === "failed") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }
    
    // Wait before next poll
    await delay(POLL_INTERVAL);
  }
  
  throw new Error("Prediction timed out after 10 minutes");
}
```

##### Python
```python
# Python example with proper polling and timeout
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/text-to-video-image-to-video-api-kwaivgi-kling-v2-5-turbo-pro"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "a3ccc39250a72749ced345996ec06d96d1d032b1a1369f45f3b9f654324036b5", "input": input_data}
    )
    
    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")
    
    prediction = response.json()
    prediction_id = prediction["id"]
    
    # Step 2: Poll for results with timeout
    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:
        # Check prediction status
        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()
        
        # Check status and return if completed
        if prediction["status"] == "succeeded":
            return prediction["output"]
        
        # Handle failure
        if prediction["status"] == "failed":
            error_msg = prediction.get("error", "Unknown error")
            raise Exception(f"Prediction failed: {error_msg}")
        
        # Wait before next poll
        time.sleep(POLL_INTERVAL)
    
    raise Exception("Prediction timed out after 10 minutes")
```

##### cURL
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-video-image-to-video-api-kwaivgi-kling-v2-5-turbo-pro/predictions"           -H "Content-Type: application/json"           -H "x-api-market-key: YOUR_API_MARKET_KEY"           -d '{
    "version": "a3ccc39250a72749ced345996ec06d96d1d032b1a1369f45f3b9f654324036b5",
    "input": {
      "prompt": "a woman is dancing in a bright studio, full body visible, smooth graceful movements in a bright studio, full body visible, smooth graceful movements",
      "duration": 5,
      "aspect_ratio": "16:9"
    }
  }'

# Response will contain a prediction ID like:
# {"id": "abcd1234", "status": "starting"}

# Step 2: Check prediction status (replace abcd1234 with the actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-video-image-to-video-api-kwaivgi-kling-v2-5-turbo-pro/predictions/abcd1234"           -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Note: You need to repeatedly poll this endpoint manually until status is "succeeded"
```

### Performance Optimization
Tips for optimizing API usage and minimizing costs:
- Each request returns one video; send separate requests (in parallel if needed) for several videos.
- Request shorter video durations to minimize processing time and costs.
- Use efficient polling intervals to avoid excessive API calls.

## FAQ
**Q: What is the maximum video duration I can request?**
A: `duration` accepts only 5 or 10 seconds (default 5).

**Q: How accurate is the prompt adherence?**
A: The model is tuned for strong prompt adherence, but results vary; use `negative_prompt` to exclude unwanted content.

**Q: Is there a limit to the number of requests I can make?**
A: Yes, the API implements rate limits. Ensure you handle rate limit errors appropriately in your code.

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

Unlock pro-level video creation from text and images with smooth motion and cinematic depth using Kling 2.5 Turbo Pro.