Pruna AI P Video Upscale API Documentation

Pruna AI P Video Upscale API Documentation

Playground

Pruna P-Video Upscale enhances video resolution up to 4K while preserving the source aspect ratio and audio, with adjustable frame rate and an optional faster processing mode. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing.

Features

P-Video Upscale increases the resolution of an existing video while preserving its aspect ratio and original soundtrack. Choose output resolutions from 720p to 4K, adjust the frame rate, and optionally enable Turbo for faster processing.

Why Choose This?

• Up to 4K output — Upscale existing videos to 720p, 1080p, 2K, or 4K.
• Original framing — Preserve the source video’s aspect ratio without stretching the image.
• Audio preserved — Keep the original soundtrack when the source contains audio.
• Frame-rate control — Choose an output frame rate of 24, 30, or 60 FPS.
• Turbo processing — Enable faster processing with a small quality trade-off.

Parameters

How to Use

1. Upload a video — Provide the source video or its URL.
2. Choose a resolution — Select 720p, 1080p, 2k, or 4k.
3. Set frame rate optional — Choose an output frame rate of 24, 30, or 60 FPS.
4. Enable Turbo optional — Turn on Turbo when faster processing is preferred.
5. Submit — Process and retrieve the upscaled MP4.

Pricing

Pricing is based on the source video duration, capped at the processing limit for the selected target_resolution and fps, then rounded up to the next whole second.

60 FPS uses twice the per-second rate of 24 or 30 FPS. Turbo does not add a surcharge. Changing fps can also change the processing limit and the number of billed seconds.

Best Use Cases

• Social videos — Prepare existing clips for higher-resolution publishing.
• Presentation footage — Improve video quality for larger screens and displays.
• Video libraries — Upgrade existing footage while preserving its framing and soundtrack.
• Marketing content — Improve existing promotional and product videos.
• Archived footage — Create higher-resolution versions of older video assets.

Pro Tips

• Use 720p or 1080p for lower-cost processing before moving to higher resolutions.
• Choose the frame rate based on the motion and source footage.
• Enable Turbo when processing speed is more important than maximum quality.
• Keep the source aspect ratio suitable for the intended publishing platform.
• Higher resolutions support fewer processed frames per request.

Notes

• Resolution targets are based on pixel area. Exact output dimensions vary with the source aspect ratio; 720p does not always mean a height of 720 pixels.

• Videos already larger than the selected target are not downscaled.

• The maximum input file size is 512 MiB.

• Clip length is limited by processed frames, not a fixed duration:

  Target	Maximum Processed Frames
  720p	2,400
  1080p	1,200
  2k	600
  4k	300

• Overlong videos are shortened before upscaling; only the beginning is retained. The remaining portion is not processed or billed.

• The retained length depends on target_resolution and fps, with a small allowance reserved to stay within the frame limit. Billed duration is rounded up to the next whole second.

Related Models

• P-Video-2 Pro Image-to-Video — Generate videos from a starting image with P-Video-2 Pro.
• P-Video-2 Pro Reference-to-Video — Generate videos using image, video, and audio references.

Authentication

For authentication details, please refer to the Authentication Guide.

API Endpoints

Submit Task & Query Result

set -euo pipefail

export WAVESPEED_API_KEY="your-api-key"

REQUEST_BODY=$(cat <<'JSON'
{
  "video": "https://interactive-examples.mdn.mozilla.net/media/cc0-videos/flower.mp4",
  "target_resolution": "1080p",
  "fps": 24,
  "turbo": false
}
JSON
)

# 1. Submit the prediction once. Never retry this request automatically:
# a retry after an unclear failure can create a second, billed task.
CHECK='The task may already exist. Check History or the predictions list before submitting again.'
if ! SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  --connect-timeout 10 --max-time 60 \
  -X POST "https://api.wavespeed.ai/api/v3/pruna-ai/p-video/upscale" \
  -H "Authorization: Bearer ${WAVESPEED_API_KEY}" \
  -H "Content-Type: application/json" \
  -d "${REQUEST_BODY}"); then
  printf 'Submit failed. %s\n' "${CHECK}" >&2
  exit 1
fi

TASK=$(printf '%s' "${SUBMIT_RESPONSE}" | jq 'if type == "object" and has("data") then .data else . end')
PREDICTION_ID=$(printf '%s' "${TASK}" | jq -r '.id // empty')
if [ -z "${PREDICTION_ID}" ]; then
  printf 'Submission response did not contain a prediction id. %s\n' "${CHECK}" >&2
  exit 1
fi
RESULT_URL="https://api.wavespeed.ai/api/v3/predictions/${PREDICTION_ID}/result"

# 2. Poll until the prediction reaches a final status.
BODY_FILE=$(mktemp)
trap 'rm -f "${BODY_FILE}"' EXIT
while true; do
  # Transient errors (429, 5xx) are retried, honoring Retry-After.
  HTTP_CODE=$(curl --silent --show-error --fail-with-body \
    --connect-timeout 10 --max-time 60 --retry 5 --retry-delay 2 \
    --output "${BODY_FILE}" --write-out '%{http_code}' \
    "${RESULT_URL}" \
    -H "Authorization: Bearer ${WAVESPEED_API_KEY}" || true)
  case "${HTTP_CODE}" in
    2??) ;;
    000|429|5??)  # dropped connection or temporary error: keep polling
      printf 'Task %s: HTTP %s, polling again in 10s\n' "${PREDICTION_ID}" "${HTTP_CODE}" >&2
      sleep 10; continue ;;
    *) printf 'Task %s: HTTP %s\n' "${PREDICTION_ID}" "${HTTP_CODE}" >&2
      cat "${BODY_FILE}" >&2; exit 1 ;;
  esac
  RESULT=$(jq 'if type == "object" and has("data") then .data else . end' "${BODY_FILE}")
  STATUS=$(printf '%s' "${RESULT}" | jq -r '.status // empty')

  case "${STATUS}" in
    completed) printf '%s\n' "${RESULT}" | jq '.outputs'; break ;;
    failed|cancelled|timeout|deleted)
      printf 'Task %s ended with status %s\n' "${PREDICTION_ID}" "${STATUS}" >&2
      printf '%s\n' "${RESULT}" | jq . >&2; exit 1 ;;
    *) sleep 2 ;;
  esac
done

Parameters

Task Submission Parameters

Request Parameters

Response Parameters

Result Request Parameters

Result Response Parameters