Name: Black Forest Labs FLUX Video Upscaler API
Brand: magicapi
SKU: api-magicapi-video-upscaler-ai-black-forest-labs-flux-video-upscale
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎞️ Video Upscaler API (Black Forest Labs FLUX Video Upscale)

## Overview
FLUX Video Upscale is a video super-resolution model from Black Forest Labs. Precise mode sharpens the footage and stays faithful to the source; creative mode restores and invents fine detail.

Send an mp4 `input_video` (at most 50 MB, 20 seconds and 2560 x 1440) and an `upscale_factor` from 1.5 to 3. Set `creativity` to 0 for precise mode or 1 for creative mode. Each request returns the URL of one mp4 video.

## Features
- **Two modes**: `creativity` 0 (precise) keeps faces, products and real people faithful; 1 (creative, the default) restores more detail in generated footage, textures and scenery.
- **Upscale factor 1.5 to 3**: the output keeps the source aspect ratio. Frames are capped at about 14.4 megapixels (4K).
- **Optional prompt**: describe the clip's content to steer the added detail, or leave it empty for a neutral upscale.
- **Adjustable moderation**: `safety_tolerance` from 0 (strictest) to 4 (most permissive).

## Use Cases
1. **Upscale AI-generated clips** to HD before publishing.
2. **Sharpen product and people footage** in precise mode without changing faces.
3. **Restore low-resolution archive or social clips** for larger screens.
4. **Prepare footage for editing** at a higher working resolution.

## Visual Examples
### Example Input
Our 2 second, 416 x 240 clip of a penguin on skis, upscaled 2x in precise mode (`creativity` 0) with no prompt.

```json
{
  "prompt": "",
  "creativity": 0,
  "input_video": "https://blog.api.market/wp-content/uploads/2026/11/video-upscale-penguin-240p-w15-input-api-market.mp4",
  "upscale_factor": 2,
  "safety_tolerance": 2
}
```

### Example Output
[Watch the example output](https://blog.api.market/wp-content/uploads/2026/11/flux-video-upscale-output-ejhmehy1-api-market.mp4): the penguin clip upscaled to 832 x 480.

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `input_video` | string (URL) | Yes |  |  | Video URL (mp4) to upscale. At most 50 MB, 20 seconds and 2560 x 1440 (2K). |
| `upscale_factor` | number | No | `2` | 1.5 to 3 | How much to scale the output relative to the source. The output keeps the source aspect ratio; frames are capped at about 14.4 megapixels (4K), so very large sources are upscaled by less. |
| `creativity` | integer | No | `1` | `0`, `1` | 0 (precise) preserves the source and sharpens it; use it for faces, products and real people. 1 (creative) restores and invents fine detail more aggressively; use it for generated footage, textures and scenery. |
| `prompt` | string | No | `""` |  | Optional description of the clip's content to steer the enhanced detail. Leave empty for a neutral upscale. |
| `safety_tolerance` | integer | No | `2` | 0 to 4 | Moderation strictness for the prompt and the output frames, from 0 (strictest) to 4 (most permissive). |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.001 per API unit.
- **Metered billing**: each request is billed per output video megapixel-second (output width x height / 1,000,000, times the output length in seconds), at the price of the mode it ran in. The total is rounded up to a whole API unit per request.

| Mode (`creativity`) | Price per output video megapixel-second |
| --- | --- |
| precise (`0`) | $0.0824 |
| creative (`1`, the default) | $0.118 |

- For example, a 5 second clip upscaled to 1920 x 1080 (2.07 megapixels) is 10.4 megapixel-seconds: about $0.854 in precise mode and $1.22 in creative mode.
- If the mode is not reported, the creative price applies. If the output size is not reported, we measure the output video; if it cannot be measured, the request is billed as 288 megapixel-seconds.
- **Example cost**: the example output measured 0.778 megapixel-seconds in precise mode: 0.778 x $0.0824 = $0.064, rounded up to 65 units ($0.065).
- **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-ai-black-forest-labs-flux-video-upscale`

### 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-ai-black-forest-labs-flux-video-upscale/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "black-forest-labs/flux-video-upscale",
    "input": {
      "prompt": "",
      "creativity": 0,
      "input_video": "https://blog.api.market/wp-content/uploads/2026/11/video-upscale-penguin-240p-w15-input-api-market.mp4",
      "upscale_factor": 2,
      "safety_tolerance": 2
    }
  }'
```

Response (201 Created):
```json
{
  "id": "ejhmehy1n5rmt0d1ngjat675fc",
  "version": "black-forest-labs/flux-video-upscale",
  "status": "starting",
  "created_at": "2026-11-05T14:37:32.457Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/video-upscaler-ai-black-forest-labs-flux-video-upscale/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "ejhmehy1n5rmt0d1ngjat675fc",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/11/flux-video-upscale-output-ejhmehy1-api-market.mp4",
  "error": null,
  "created_at": "2026-11-05T14:37:32.457Z",
  "started_at": "2026-11-05T14:37:32.488Z",
  "completed_at": "2026-11-05T14:39:12.871Z"
}
```

`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 `input_video` or an `upscale_factor` above 3.
- **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-ai-black-forest-labs-flux-video-upscale";

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: "black-forest-labs/flux-video-upscale", 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({
  "prompt": "",
  "creativity": 0,
  "input_video": "https://blog.api.market/wp-content/uploads/2026/11/video-upscale-penguin-240p-w15-input-api-market.mp4",
  "upscale_factor": 2,
  "safety_tolerance": 2
}).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-ai-black-forest-labs-flux-video-upscale"


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": "black-forest-labs/flux-video-upscale", "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({
    "prompt": "",
    "creativity": 0,
    "input_video": "https://blog.api.market/wp-content/uploads/2026/11/video-upscale-penguin-240p-w15-input-api-market.mp4",
    "upscale_factor": 2,
    "safety_tolerance": 2
}))
```

## FAQ
- **Which mode should I use?**
  - Precise (`creativity` 0) for faces, products and real people, where the result must match the source. Creative (`creativity` 1, the default) for generated footage, textures and scenery, where restored detail matters more than strict fidelity.
- **What videos can I send?**
  - An mp4 of at most 50 MB, 20 seconds and 2560 x 1440 source resolution.
- **How is the price calculated?**
  - Per output video megapixel-second: output width x height in megapixels, times seconds, times $0.0824 (precise) or $0.118 (creative), rounded up to a whole $0.001 unit per request. The 2 second example cost $0.065.
- **Why is my output smaller than the factor I asked for?**
  - Output frames are capped at about 14.4 megapixels (4K), so large sources are upscaled by less than the requested factor.
- **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 videos 1.5x to 3x with FLUX Video Upscale from Black Forest Labs, in precise or creative mode. From $0.0824 per output video megapixel-second, pay as you go.