Name: ByteDance Video Upscaler Video Upscaling and Enhancement API
Brand: magicapi
SKU: api-magicapi-video-upscaler-enhancer-bytedance-video-upscaler
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎞️ Video Upscaler API (ByteDance Video Upscaler)

## Overview
ByteDance Video Upscaler upscales and enhances a video. Its developer describes it as upscaling video up to 4K at 60 fps, with scene-aware presets for AI-generated content, short dramas, user-generated content and film restoration.

Send a `video` URL and choose a `target_resolution` (240p to 4k), a `target_fps` (24, 30, 60 or 120), a `scene` preset and a `processing_type`. Each request returns the URL of one MP4 video. Price depends on the processing tier, resolution, frame rate and length of the output.

## Features
- **Resolutions from 240p to 4K**: `target_resolution` takes `240p`, `360p`, `480p`, `540p`, `720p`, `1080p`, `2k` or `4k` (default `4k`).
- **Frame rate conversion**: `target_fps` takes `24`, `30`, `60` or `120` (default `60`). Frames are interpolated when the target is higher than the source.
- **Scene presets**: `scene` takes `aigc` (default, AI-generated video), `short_series` (short-form drama), `ugc` (user-generated content), `old_film` (film restoration) or `common` (everything else).
- **Two processing tiers**: `standard` (default) or `pro`, a higher-quality model with better skin textures and fine detail for footage of real people.

## Use Cases
1. **AI-generated video**: take 720p or 1080p clips from a video generator to 2K or 4K for delivery.
2. **Short dramas and social video**: sharpen short-form episodes and user-generated clips with the `short_series` or `ugc` presets.
3. **Archive footage**: enhance old film transfers with the `old_film` preset.
4. **Smoother motion**: raise 24 or 30 fps footage to 60 or 120 fps with frame interpolation.

## Visual Examples
### Example Input
A 2 second, 240p clip of a penguin. [Watch the input video](https://blog.api.market/wp-content/uploads/2026/11/video-upscale-penguin-240p-w15-input-api-market.mp4)

Settings: `target_resolution` `720p`, `target_fps` `30`, `scene` `aigc`, `processing_type` `standard`.

### Example Output
The same clip upscaled to 720p at 30 fps (1.934 seconds long). [Watch the example output](https://blog.api.market/wp-content/uploads/2026/11/video-upscaler-output-wznaz4we-api-market.mp4)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `video` | string (URL) | Yes | none |  | Video URL. The video to upscale and enhance. It was built with AI-generated video in mind (for example 1080p, 24 fps Seedance 2.0 output), but any video works. |
| `processing_type` | string | No | `standard` | `standard`, `pro` | Processing tier. 'standard' works for every request. 'pro' uses a higher-quality enhancement model with better skin textures and fine detail for footage of real people; its developer notes it must be enabled for the account first, so it can fail. |
| `scene` | string | No | `aigc` | `aigc`, `short_series`, `ugc`, `old_film`, `common` | Scene-based enhancement preset. 'aigc' is recommended for AI-generated video, 'short_series' is tuned for short-form drama, 'ugc' for user-generated content, 'old_film' for film restoration, 'common' for everything else. |
| `target_resolution` | string | No | `4k` | `240p`, `360p`, `480p`, `540p`, `720p`, `1080p`, `2k`, `4k` | Target output resolution. Use lowercase '2k' and '4k'. '4k' is the maximum. |
| `target_fps` | integer | No | `60` | `24`, `30`, `60`, `120` | Target output frame rate. Frame interpolation is applied when it is higher than the source frame rate. |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.0041 per API unit.
- **1 API unit = 1 second of output video, rounded up per request, times the factor of your settings.** The factor depends on `processing_type`, `target_resolution` and `target_fps`. Price per second of output video:

| `processing_type` | `target_resolution` | `target_fps` 24 or 30 | `target_fps` 60 or 120 |
| --- | --- | --- | --- |
| `standard` | `240p`, `360p`, `480p`, `540p`, `720p` | $0.0041 (x1) | $0.0082 (x2) |
| `standard` | `1080p` | $0.0082 (x2) | $0.0164 (x4) |
| `standard` | `2k` | $0.0164 (x4) | $0.0328 (x8) |
| `standard` | `4k` | $0.0328 (x8) | $0.0656 (x16) |
| `pro` | `240p`, `360p`, `480p`, `540p`, `720p` | $0.041 (x10) | $0.082 (x20) |
| `pro` | `1080p` | $0.082 (x20) | $0.164 (x40) |
| `pro` | `2k` | $0.164 (x40) | $0.328 (x80) |
| `pro` | `4k` | $0.328 (x80) | $0.656 (x160) |

- **If you leave the settings out**, the defaults apply (`standard`, `4k`, `60` fps): factor 16, $0.0656 per second of output video. Set `target_resolution` and `target_fps` explicitly to pay less.
- `scene` does not change the price.
- **Example cost**: the example output was 1.934 seconds long, rounded up to 2 seconds, at `standard`, `720p`, `30` fps (factor 1): 2 API units, $0.0082.
- **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 go to: `https://prod.api.market/api/v1/magicapi/video-upscaler-enhancer-bytedance-video-upscaler`

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

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/video-upscaler-enhancer-bytedance-video-upscaler/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "bytedance/video-upscaler",
    "input": {
      "video": "https://blog.api.market/wp-content/uploads/2026/11/video-upscale-penguin-240p-w15-input-api-market.mp4",
      "scene": "aigc",
      "target_fps": 30,
      "processing_type": "standard",
      "target_resolution": "720p"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "wznaz4we7drmy0d1mvhtzysegr",
  "version": "bytedance/video-upscaler",
  "status": "starting",
  "created_at": "2026-11-04T14:08:13.371Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/video-upscaler-enhancer-bytedance-video-upscaler/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "wznaz4we7drmy0d1mvhtzysegr",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/11/video-upscaler-output-wznaz4we-api-market.mp4",
  "error": null,
  "created_at": "2026-11-04T14:08:13.371Z",
  "started_at": "2026-11-04T14:08:13.388216637Z",
  "completed_at": "2026-11-04T14:09:41.209709283Z"
}
```

`output` is a single URL string pointing to the upscaled MP4 video.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `video`, an uppercase `4K` instead of `4k`, or a `target_fps` that is not 24, 30, 60 or 120.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
Requests are rate limited to keep usage fair. If you receive a 429 response, wait and retry with exponential backoff.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/video-upscaler-enhancer-bytedance-video-upscaler";

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: "bytedance/video-upscaler", input })
  });

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

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

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 1000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    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(pollInterval);
  }

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

createAndWaitForPrediction({
  "video": "https://blog.api.market/wp-content/uploads/2026/11/video-upscale-penguin-240p-w15-input-api-market.mp4",
  "scene": "aigc",
  "target_fps": 30,
  "processing_type": "standard",
  "target_resolution": "720p"
}).then((output) => console.log(output));
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/video-upscaler-enhancer-bytedance-video-upscaler"


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": "bytedance/video-upscaler", "input": input_data},
    )

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

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


def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 1
    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"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

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


print(create_and_wait_for_prediction({
    "video": "https://blog.api.market/wp-content/uploads/2026/11/video-upscale-penguin-240p-w15-input-api-market.mp4",
    "scene": "aigc",
    "target_fps": 30,
    "processing_type": "standard",
    "target_resolution": "720p"
}))
```

## FAQ
- **How much does a 10 second clip cost?**
  - It depends on the settings. At `standard`, `1080p`, `30` fps it is 10 x $0.0082 = $0.082. With every setting left at its default (`standard`, `4k`, `60` fps) it is 10 x $0.0656 = $0.656.
- **Which `scene` should I pick?**
  - `aigc` for output from video generation models, `short_series` for short-form drama, `ugc` for phone and social footage, `old_film` for film restoration and `common` for anything else.
- **Can I use `pro`?**
  - Its developer notes that `pro` must be enabled for the account before it works, so `pro` requests can fail. Failed requests are not billed. Use `standard` unless `pro` works for you.
- **Does a higher frame rate make the video longer?**
  - No. Extra frames are interpolated between existing ones, so the length stays the same. Frame rates of 60 and 120 fps cost twice as much per second as 24 and 30 fps.
- **Is the 201 response from POST an error?**
  - No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## Contact Us
If you have any questions, reach out to us through the chat on the bottom right of the page.


Upscale and enhance videos up to 4K at up to 120 fps with ByteDance Video Upscaler, with presets for AI-generated video, short dramas, UGC and old film. From $0.0041 per second of output video, pay as you go.