PixVerse video upscale API editorial cover with the MODELLIX wordmark, a two-line title, and a video upscaling workflow capsule

The PixVerse video upscale API is one endpoint — POST /openapi/v2/video/upscale/generate on app-api.pixverse.ai — that takes an existing video and returns a sharper, higher-resolution version of it. It is billed at 5 credits per second of source video on the official pricing page, which works out to about $0.05/second if you buy credits at the $10 / 1,000-credit tier. That math, the two input paths, and the code below are the parts the current documentation page does not spell out for you.

Upscale is a post-processing effect, not a generator: it increases resolution and clarity while preserving the content, style, and motion of the source clip. It is PixVerse’s own model running behind the API, so the same effect you can trigger in the web app is what this endpoint does programmatically. One warning up front: the official upscale documentation does not promise a specific output resolution such as 4K — a reseller’s model page advertises “4K” output while noting its own spec is indicative rather than guaranteed, so budget a test clip before you promise resolution in your product. All figures in this guide were read from official PixVerse pages on August 5, 2026.

What the PixVerse video upscale API does — and what it costs

The official Upscale Video API documentation defines one asynchronous task. You submit a video, receive a new video_id, poll the status endpoint until it finishes, and download the result. The submit response returns both the new task’s video_id and the credit cost that was charged:

1
2
3
4
5
6
7
8
{
  "ErrCode": 0,
  "ErrMsg": "Success",
  "Resp": {
    "video_id": 987654,
    "credit": 50
  }
}

The request body accepts exactly one of two source fields, which we unpack in the next section: source_video_id for a video PixVerse already generated, or video_media_id for a clip you uploaded to your account.

On cost, the official PixVerse pricing page lists Upscale under its effect pricing at 5 credits per second (billing rule: credits per 1s, rounded up). Credits are purchased in packs — $10 buys 1,000 credits, and larger packs exist up to $5,000 / 500,000 credits. At the smallest pack that is $0.05 per second of source video, before any rounding. That is the number to put in a budget spreadsheet; the pricing page’s separate “$1 = 5 videos (v6, 720p, 5s, no audio)” example is a different calculation for generated clips and does not apply to upscaling.

Two things the pricing page does not tell you, so we will: credits are PixVerse Platform credits, not a dollar balance — you buy them in packs and spend them per second. And the API has no free tier: every upscale request consumes credits, so the “pixverse video upscale api free” searches you will see around this topic have a short answer — free trials live on the consumer app, not the API. Our PixVerse tutorial walks through the app-side trial if that is the path you actually need.

Two input paths: PixVerse-generated or uploaded video

The upscale endpoint takes one of two identifiers, and which one you send depends on where the video lives:

Field Use when Where the ID comes from
source_video_id The clip was produced by PixVerse The video_id returned by any generation task (text-to-video, image-to-video, extend, fusion, and so on)
video_media_id The clip is your own footage The media_id returned by the media upload endpoint

The second path is the one most integrations miss. To upscale footage that PixVerse never generated, you first upload it:

1
2
3
4
curl --location 'https://app-api.pixverse.ai/openapi/v2/media/upload' \
  --header 'API-KEY: YOUR_API_KEY' \
  --header 'Ai-trace-id: your-unique-trace-id' \
  --form 'file=@clip.mp4'

The upload response returns a media_id plus a hosted url; you then send that media_id as video_media_id in the upscale request. For upscaling, the upload documentation caps input at 100MB and 30 seconds of video, and all video inputs are limited to 1920px on the longest side (width or height). Supported containers are MP4, MOV, and WebM. If your pipeline produces longer or larger clips, split them before uploading — the 30-second ceiling is the practical constraint on what one upscale task can process.

Practical routing rule: if the video came out of a generation task this session, pass source_video_id directly and skip the upload entirely. If it is an asset your users bring in, upload once, keep the media_id, and reuse it for every upscale request — you pay for uploads in storage/limits, not per upsert.

Calling the endpoint: submit, poll, retrieve

Before any request you need an API key — the official API key guide has you create a key on the platform (it is shown once), send it in the API-KEY header, and use a unique Ai-trace-id per request. Reusing a trace id is a common source of “nothing happened” reports: PixVerse deduplicates on it.

A minimal upscale submission:

1
2
3
4
5
6
7
curl --location 'https://app-api.pixverse.ai/openapi/v2/video/upscale/generate' \
  --header 'API-KEY: YOUR_API_KEY' \
  --header 'Ai-trace-id: your-unique-trace-id' \
  --header 'Content-Type: application/json' \
  --data '{
    "source_video_id": 123456
  }'

The response gives you the new task’s video_id. Upscaling is asynchronous — the finished clip does not exist yet. Poll the status endpoint with that id:

1
2
3
curl --location 'https://app-api.pixverse.ai/openapi/v2/video/result/987654' \
  --header 'API-KEY: YOUR_API_KEY' \
  --header 'Ai-trace-id: another-unique-trace-id'

The official video generation status guide defines the status codes: 1 = success (the response includes the url to download), 5 = waiting for generation (poll every 3–5 seconds), 7 = content moderation failure, 8 = generation failed. Polling faster than 3 seconds gains nothing; the docs recommend the 3–5 second interval while status is 5.

Here is the whole loop in Python, which is the pattern you will ship:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import time
import uuid
import requests

API_KEY = "YOUR_API_KEY"
BASE = "https://app-api.pixverse.ai/openapi/v2"

def upscale_video(source_video_id=None, video_media_id=None):
    body = {}
    if source_video_id is not None:
        body["source_video_id"] = source_video_id
    if video_media_id is not None:
        body["video_media_id"] = video_media_id
    resp = requests.post(
        f"{BASE}/video/upscale/generate",
        headers={
            "API-KEY": API_KEY,
            "Ai-trace-id": str(uuid.uuid4()),
            "Content-Type": "application/json",
        },
        json=body,
        timeout=30,
    )
    resp.raise_for_status()
    data = resp.json()
    if data["ErrCode"] != 0:
        raise RuntimeError(f"{data['ErrCode']}: {data['ErrMsg']}")
    return data["Resp"]["video_id"]

def wait_for_video(video_id, interval=4, timeout=600):
    started = time.time()
    while time.time() - started < timeout:
        resp = requests.get(
            f"{BASE}/video/result/{video_id}",
            headers={"API-KEY": API_KEY, "Ai-trace-id": str(uuid.uuid4())},
            timeout=30,
        )
        result = resp.json()["Resp"]
        if result["status"] == 1:
            return result["url"]
        if result["status"] in (7, 8):
            raise RuntimeError(f"task failed with status {result['status']}")
        time.sleep(interval)
    raise TimeoutError("upscale task did not finish in time")
1
2
3
# usage
task_id = upscale_video(source_video_id=123456)
download_url = wait_for_video(task_id)
PixVerse upscale API workflow diagram: source_video_id or video_media_id into the upscale generate endpoint, then poll the result endpoint until status 1 returns the download URL

Figure 1: The PixVerse video upscale API loop — submit with one of the two input identifiers, poll status until 1, then download from the returned URL. Reconstructed from the official API documentation on August 5, 2026.

For teams that already call several PixVerse endpoints, our PixVerse API integration guide covers authentication, polling, error codes, and production patterns across the whole platform — upscale is one of the effects in that same loop.

Credit cost, limits, and production options

Upscale is charged per second of source video, rounded up, at 5 credits/second. A 10-second clip costs 50 credits, which is $0.50 at the $10 / 1,000-credit pack price:

PixVerse upscale credit cost schematic: 5 credits per second multiplied by clip duration, deducted from a purchased credit pack, about 0.05 USD per second at the 10-dollar pack

Figure 2: Credit math for the PixVerse video upscale API from the official pricing page, August 5, 2026: 5 credits per second × duration, rounded up; at $10 per 1,000 credits that is about $0.05 per second. Not a total-task price for other effects.

Budgeting checks before a batch run:

  • Check balance first. The platform exposes a credit-balance endpoint; a batch of upscale jobs can clear a small pack quickly, and the error path for an empty balance is a failed task, not a warning.
  • Watch concurrency. The error-code list includes “reached the limit for concurrent generations” — queue long batches instead of firing them all at once.
  • Input caps. 100MB / 30s / 1920px per upscale upload (see the input section). Plan chunking in the pipeline, not in the error handler.
  • Webhooks beat polling in production. The official webhook integration guide lists the upscale endpoint as webhook-supported, with signed deliveries to verify. If you run many tasks, webhooks remove the polling loop entirely.

For a full walkthrough of the credit system and the per-second API rates across PixVerse’s other effects, our PixVerse pricing breakdown compares the official tables side by side.

Errors and troubleshooting

Upscale failures fall into a small set of repeatable codes. The upscale endpoint documentation names two directly, and the platform’s error-code reference covers the rest:

Code Meaning What to do
400017 File limit exceeded (upscale doc wording) / invalid parameter (general list) Check the input file against the 100MB / 30s / 1920px caps
500047 Invalid video ID Confirm source_video_id / video_media_id is real and belongs to your account
500008 Requested data not found The task id is wrong or the result was cleaned up; re-check your stored ids
500090 Insufficient balance Top up credits, then resubmit
500063 Content moderation failure The input video failed review; replace the clip
500069 System high load Retry after a short backoff
500044 Concurrent generation limit reached Add a queue to your pipeline

Two behaviors are worth designing around. First, a status of 7 (content moderation failure) means the input clip was rejected — the official FAQ addresses whether credits are refunded for failed generations, so confirm the current policy on that page before you build an automatic retry loop that assumes a refund. Second, failures happen after the submit response, which is why the credit field in that response exists: you can log the charged amount per task and reconcile it against your balance history instead of discovering a discrepancy at month end.

Direct PixVerse API vs an aggregator route

Once the workflow works, the remaining decision is where to run it: the official PixVerse platform directly, or an aggregator that resells the same model. Both run PixVerse’s upscaler — this is a routing decision, not a quality claim.

Consideration Direct PixVerse Aggregator route
Billing unit Platform credits, bought in packs USD per second, pay-as-you-go
Auth surface PixVerse API key + per-request trace ids One key for many providers
Upscale rate 5 credits/sec ≈ $0.05/sec at the $10 pack pixverse/upscale-video displayed at $0.0575/sec
Extra surface Manage credits, packs, limits yourself One dashboard/billing for all models you call

Modellix is an API aggregator and has a commercial interest in this comparison. We carry the PixVerse upscaler as pixverse/upscale-video at $0.0575/second, alongside 210+ other image and video models behind one REST API — see the PixVerse provider page for the current catalog. None of that makes the aggregator “cheaper”: at the smallest official credit pack the direct rate is nominally lower per second, and the two billing systems (credit packs vs USD usage) are not directly interchangeable. The honest reasons to pick an aggregator are operational — one key, one invoice, no credit-pack commitment — not a blanket price claim. If you already call several model providers, try the Modellix API with the upscaler as one route among many; if PixVerse is your only provider, the direct route with a credit pack is simpler to reason about.

FAQ

Is the PixVerse video upscale API free?

No. The API runs on PixVerse Platform credits — the pricing page lists Upscale at 5 credits per second. The free trial counter lives on the consumer web app, not the API.

Can I upscale any video with the PixVerse video upscale API?

Through the API you can upscale two kinds of input: videos PixVerse generated (source_video_id) and videos you upload (video_media_id). Uploads are capped at 100MB, 30 seconds, and 1920px on the longest side per the upload documentation.

Does PixVerse upscale to 4K?

The official upscale documentation does not commit to an output resolution. One reseller page advertises “4K” while noting its own spec is indicative rather than guaranteed. Test the exact source resolution you plan to ship before promising 4K to your users.

How much does the PixVerse video upscale API cost?

5 credits per second of source video, rounded up, per the official pricing page. At the $10 / 1,000-credit pack that is about $0.05 per second (as of August 5, 2026); larger packs change the effective rate. Re-check the live page before committing budget.

Is there an official PixVerse upscale GitHub wrapper?

PixVerse does not publish an official GitHub SDK for upscaling on the pages we verified; the authoritative references are the REST API docs. Third-party wrappers exist on GitHub but are not maintained by PixVerse — evaluate them like any unofficial dependency.

Direct PixVerse or an aggregator for video upscaling?

Both run the same PixVerse model. Direct gives you the official credit pricing and full control; an aggregator gives you one key and one bill across providers. Pick on operational needs, and compare the exact rate on the day you commit — pricing on both sides changes.

Sources accessed August 5, 2026: the official Upscale Video API documentation, the PixVerse pricing page, the media upload guide, the video generation status guide, the webhook integration guide, the error-code reference, and the API key guide. PixVerse pricing, limits, and endpoints change without notice; treat everything version-specific as current as of that date. Modellix is an aggregator and has a commercial interest in the comparison above. Cover image is illustrative artwork, not a PixVerse product screenshot.