# Kandinsky 6.0 VSR Lite

> Kandinsky 6.0 VSR Lite is a fast, lightweight video super-resolution model for quick, cost-efficient upscaling.


## Overview

- **Endpoint**: `https://fal.run/fal-ai/kandinsky6-vsr/lite`
- **Model ID**: `fal-ai/kandinsky6-vsr/lite`
- **Category**: video-to-video
- **Kind**: inference
**Description**: Kandinsky 6.0 VSR Lite is the speed-optimized version of Kandinsky 6.0 VSR. It upscales video with lower latency and cost, which makes it a good fit for previews, high-volume pipelines, and workflows where turnaround matters more than maximum detail.

**Tags**: upscale, video-to-video



## Pricing

Your request will cost **$0.00036** per unit. 1 unit = 1 megapixel of output × frames at 5 inference steps.

For more details, see [fal.ai pricing](https://fal.ai/pricing).

## API Information

This model can be used via our HTTP API or more conveniently via our client libraries.
See the input and output schema below, as well as the usage examples.


### Input Schema

The API accepts the following input parameters:


- **`video_url`** (`string`, _required_):
  The input video to upscale. Clips are resampled to 24fps and capped at 121 frames (~5s).
  - Examples: "https://storage.googleapis.com/falserverless/example_inputs/seedvr-input.mp4"

- **`upscale_factor`** (`UpscaleFactorEnum`, _optional_):
  Total upscale factor applied to the input resolution. One of 2, 2.25 or 4. Default value: `"2.25"`
  - Default: `2.25`
  - Options: `2`, `2.25`, `4`

- **`num_inference_steps`** (`integer`, _optional_):
  The number of denoising steps used for each tile. Default value: `5`
  - Default: `5`
  - Range: `2` to `50`

- **`seed`** (`integer`, _optional_):
  The random seed used for the generation process.

- **`sync_mode`** (`boolean`, _optional_):
  If `True`, the media will be returned as a data URI and the output data won't be available in the request history.
  - Default: `false`



**Required Parameters Example**:

```json
{
  "video_url": "https://storage.googleapis.com/falserverless/example_inputs/seedvr-input.mp4"
}
```

**Full Example**:

```json
{
  "video_url": "https://storage.googleapis.com/falserverless/example_inputs/seedvr-input.mp4",
  "upscale_factor": 2.25,
  "num_inference_steps": 5
}
```


### Output Schema

The API returns the following output format:

- **`video`** (`File`, _required_):
  Upscaled video file after processing
  - Examples: {"url":"https://storage.googleapis.com/falserverless/example_outputs/seedvr-output.mp4","content_type":"video/mp4"}

- **`seed`** (`integer`, _required_):
  The random seed used for the generation process.



**Example Response**:

```json
{
  "video": {
    "url": "https://storage.googleapis.com/falserverless/example_outputs/seedvr-output.mp4",
    "content_type": "video/mp4"
  }
}
```


## Usage Examples

### cURL

```bash
curl --request POST \
  --url https://fal.run/fal-ai/kandinsky6-vsr/lite \
  --header "Authorization: Key $FAL_KEY" \
  --header "Content-Type: application/json" \
  --data '{
     "video_url": "https://storage.googleapis.com/falserverless/example_inputs/seedvr-input.mp4"
   }'
```

### Python

Ensure you have the Python client installed:

```bash
pip install fal-client
```

Then use the API client to make requests:

```python
import fal_client

def on_queue_update(update):
    if isinstance(update, fal_client.InProgress):
        for log in update.logs:
           print(log["message"])

result = fal_client.subscribe(
    "fal-ai/kandinsky6-vsr/lite",
    arguments={
        "video_url": "https://storage.googleapis.com/falserverless/example_inputs/seedvr-input.mp4"
    },
    with_logs=True,
    on_queue_update=on_queue_update,
)
print(result)
```

### JavaScript

Ensure you have the JavaScript client installed:

```bash
npm install --save @fal-ai/client
```

Then use the API client to make requests:

```javascript
import { fal } from "@fal-ai/client";

const result = await fal.subscribe("fal-ai/kandinsky6-vsr/lite", {
  input: {
    video_url: "https://storage.googleapis.com/falserverless/example_inputs/seedvr-input.mp4"
  },
  logs: true,
  onQueueUpdate: (update) => {
    if (update.status === "IN_PROGRESS") {
      update.logs.map((log) => log.message).forEach(console.log);
    }
  },
});
console.log(result.data);
console.log(result.requestId);
```


## Additional Resources

### Documentation

- [Model Playground](https://fal.ai/models/fal-ai/kandinsky6-vsr/lite)
- [API Documentation](https://fal.ai/models/fal-ai/kandinsky6-vsr/lite/api)
- [OpenAPI Schema](https://fal.ai/api/openapi/queue/openapi.json?endpoint_id=fal-ai/kandinsky6-vsr/lite)

### fal.ai Platform

- [Platform Documentation](https://fal.ai/docs/documentation)
- [Python Client](https://fal.ai/docs/api-reference/client-libraries/python)
- [JavaScript Client](https://fal.ai/docs/api-reference/client-libraries/javascript)

### Other agent-readable surfaces

This file covers one model. To find anything else:

- [Platform overview](https://fal.ai/llms.txt): Entry points and representative endpoint IDs
- [Documentation index](https://fal.ai/docs/llms.txt): Every documentation page
- [Full documentation text](https://fal.ai/docs/llms-full.txt): The whole documentation inlined
- Any other model: `https://fal.ai/models/<endpoint-id>/llms.txt`