Name: SeedVR2 API: Video and Image Restoration by ByteDance
Brand: magicapi
SKU: api-magicapi-video-image-restoration-api-zsxkib-seedvr2
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎬 Video and Image Restoration API (ByteDance SeedVR2)

## Overview
SeedVR2 is a one-step video and image restoration model from ByteDance Seed. This version can switch between the 3B and 7B model sizes and has an optional color fix.

Send a video (mp4 or mov) or an image (png, jpg or webp) as `media`. The response is the URL of the restored file: a video for video input, an image for image input. You can set the restoration strength with `cfg_scale`, the number of sampling steps, the frame rate of video output and the format and quality of image output.

## Features
- **Video and images**: `media` accepts mp4 and mov videos and png, jpg and webp images.
- **Model size**: `model_variant` is `3b` (default) or `7b`.
- **One-step mode**: `sample_steps` from 1 to 4 (default 1, the fast one-step mode).
- **Restoration strength**: `cfg_scale` from 0 to 15 (default 1); higher means stronger restoration.
- **Color fix**: `apply_color_fix` (default `false`) applies wavelet color correction.
- **Video frame rate**: `fps` from 1 to 120 (default 24) for video outputs.
- **Image output**: `output_format` `png`, `webp` (default) or `jpg`, with `output_quality` 10 to 100 (default 90) for jpg and webp.
- **Seed**: set `seed` to reproduce a result.

## Use Cases
1. **Old or low-quality photos**: restore a degraded photo, as in the example.
2. **Degraded video clips**: restore mp4 or mov footage in one request.
3. **Archive material**: improve scanned photos and old recordings before reuse.
4. **Asset cleanup**: restore product or stock images that were saved at low quality.

## Visual Examples
### Example Input
An image input, restored with the `3b` model, 1 sample step, `cfg_scale` 1 and `apply_color_fix` set to `true`, saved as `webp` at quality 90:

![SeedVR2 example input: the degraded source image](https://blog.api.market/wp-content/uploads/2026/10/seedvr2-input-api-market.png)

### Example Output
![SeedVR2 example output: the restored image](https://blog.api.market/wp-content/uploads/2026/10/seedvr2-output-6ar5hv6x-api-market.webp)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `media` | string (URL) | Yes |  |  | Video (mp4 or mov) or image (png, jpg or webp) URL to restore |
| `cfg_scale` | number | No | `1` | 0 to 15 | Classifier-free guidance scale (higher means stronger restoration) |
| `sample_steps` | integer | No | `1` | 1 to 4 | Sampling steps (1 is the fast one-step mode) |
| `sp_size` | integer | No | `1` | 1 to 4 | Sequence-parallel shard setting. This single-GPU build only accepts 1 |
| `fps` | integer | No | `24` | 1 to 120 | Frames per second for video outputs |
| `seed` | integer | No | none |  | Random seed. Leave blank for a random seed each call |
| `output_format` | string | No | `webp` | `png`, `webp`, `jpg` | Image output format (only used for image inputs) |
| `output_quality` | integer | No | `90` | 10 to 100 | Image quality for lossy formats (jpg and webp) |
| `apply_color_fix` | boolean | No | `false` |  | Apply optional wavelet color correction |
| `model_variant` | string | No | `3b` | `3b`, `7b` | Model size to run |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.04 per API unit.
- **1 API unit = 1 request with up to 23 seconds of processing time.** A request that takes longer uses one unit per started 23-second block (for example, 47 seconds of processing is 3 units, $0.12).
- **Example cost**: the request below took 6.04 seconds of processing, so it used 1 API unit = **$0.04**.
- Videos, longer clips, more `sample_steps` and the `7b` model take longer to process, so they can use several units per request.
- **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-image-restoration-api-zsxkib-seedvr2`

### 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-image-restoration-api-zsxkib-seedvr2/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "ca98249be9cb623f02a80a7851a2b1a33d5104c251a8f5a1588f251f79bf7c78",
    "input": {
      "fps": 24,
      "media": "https://blog.api.market/wp-content/uploads/2026/10/seedvr2-input-api-market.png",
      "sp_size": 1,
      "cfg_scale": 1,
      "sample_steps": 1,
      "model_variant": "3b",
      "output_format": "webp",
      "output_quality": 90,
      "apply_color_fix": true
    }
  }'
```

Response (201 Created):
```json
{
  "id": "6ar5hv6xhnrp20d1c6p91ycwym",
  "version": "ca98249be9cb623f02a80a7851a2b1a33d5104c251a8f5a1588f251f79bf7c78",
  "status": "starting",
  "created_at": "2026-10-22T03:34:41.457Z"
}
```

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

Response when the prediction has finished (200 OK):
```json
{
  "id": "6ar5hv6xhnrp20d1c6p91ycwym",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/seedvr2-output-6ar5hv6x-api-market.webp",
  "error": null,
  "created_at": "2026-10-22T03:34:41.457Z",
  "started_at": "2026-10-22T03:34:41.957Z",
  "completed_at": "2026-10-22T03:34:47.549Z"
}
```

`output` is a single URL string pointing to the restored file: an image for image input, a video for video input.

### 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 `media` URL, an `sp_size` other than 1 or a `sample_steps` above 4.
- **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
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.
## 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-image-restoration-api-zsxkib-seedvr2";

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: "ca98249be9cb623f02a80a7851a2b1a33d5104c251a8f5a1588f251f79bf7c78", 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({
  "fps": 24,
  "media": "https://blog.api.market/wp-content/uploads/2026/10/seedvr2-input-api-market.png",
  "sp_size": 1,
  "cfg_scale": 1,
  "sample_steps": 1,
  "model_variant": "3b",
  "output_format": "webp",
  "output_quality": 90,
  "apply_color_fix": true
}).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-image-restoration-api-zsxkib-seedvr2"

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": "ca98249be9cb623f02a80a7851a2b1a33d5104c251a8f5a1588f251f79bf7c78", "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")

output = create_and_wait_for_prediction({
    "fps": 24,
    "media": "https://blog.api.market/wp-content/uploads/2026/10/seedvr2-input-api-market.png",
    "sp_size": 1,
    "cfg_scale": 1,
    "sample_steps": 1,
    "model_variant": "3b",
    "output_format": "webp",
    "output_quality": 90,
    "apply_color_fix": True
})
print(output)
```

## FAQ
- **Which files can I restore?**
  - Videos in mp4 or mov format and images in png, jpg or webp format, passed as a URL in `media`.
- **Should I use `3b` or `7b`?**
  - `3b` is the default. `7b` is the larger model; it can take longer to process, which can use more units.
- **What does `apply_color_fix` do?**
  - It applies wavelet color correction to the result. It is off by default; the example turned it on.
- **What should I set `sp_size` to?**
  - Leave it at 1. This build only accepts 1.
- **How is a request billed?**
  - $0.04 per request that takes up to 23 seconds of processing; longer requests use one unit per started 23-second block. The example image took 6.04 seconds, so it cost $0.04.
- **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 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.


SeedVR2 API by ByteDance: restore degraded videos and images in one step with the 3B or 7B model and an optional color fix. Pay as you go per request.