GPT Image 2.5 is LIVE — Flare & Sunburst | Try in Image Generator →

pruna-ai/

Pruna P-Video-2-Pro Image-to-Video generates videos from input images with optional last-frame guidance, 480P / 768P output, generated audio, and explicit controls for duration, resolution, and draft mode. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing.

image-to-video
Input
Enable Safety Checker

Idle

$0.02per run·~50 / $1

Next:

ExamplesView all

He flips the photograph over and notices a handwritten message on the back. At the same moment, the compartment door slowly slides open and a woman appears in the doorway, staring at the handbag. The camera begins close on the photo, then pans toward the opening door. Classic period suspense, controlled acting, cinematic train ambience.

The sword slowly descends into her hand, sending soft ripples across the water. As she grips it, faint light travels outward through the lake and the surrounding mist begins glowing. The camera starts low at the waterline and rises toward her face. Mythic fantasy atmosphere, elegant magical motion, cinematic reveal.

Related Models

README

Pruna P-Video-2 Pro Image-to-Video

Pruna P-Video-2 Pro Image-to-Video generates videos from a first-frame reference image and a text prompt. The input image determines the output canvas, while the prompt controls motion, scene direction, camera movement, and visual style. You can also provide an optional last-frame image for stronger start-to-end-frame control.

Why Choose This?

  • Image-to-video generation
    Animate a first-frame image into a generated video.

  • First-frame canvas control
    The input image determines the output canvas and visual starting point.

  • Optional last-frame guidance
    Use last_image to guide the ending frame of the generated video.

  • 480p and 768p output
    Use 480p for lower-cost generation or 768p for higher-resolution output.

  • Speed and quality modes
    Choose mode=speed for faster generation or mode=quality for higher-quality generation. Default: speed.

Parameters

ParameterRequiredDescription
promptYesText prompt describing the video to generate, including motion, scene direction, camera movement, and visual style.
imageYesFirst-frame reference image. Upload an image or provide a public URL. The reference image determines the output canvas.
last_imageNoOptional last-frame reference image. Upload an image or provide a public URL. Omit when unused.
durationNoVideo duration in seconds. Range: 5–15. Default: 5.
resolutionNoOutput video resolution: 480p or 768p. Default: 768p.
modeNoGeneration mode: speed for faster generation or quality for higher-quality generation. Default: speed. Independent of prompt_upsampler.
prompt_upsamplerNoPrompt expansion mode: off, turbo, or max. Default: turbo. Independent of mode; does not change the price.
seedNoOptional random seed for reproducible generation. Omit for an upstream-selected random seed.

How to Use

  1. Write a prompt — Describe the motion, action, camera movement, lighting, mood, and scene direction.
  2. Upload a first-frame image — Provide the image that should define the starting frame and output canvas.
  3. Add last-frame guidance optional — Use last_image when you want to guide the final frame.
  4. Set duration — Choose a video length from 5 to 15 seconds.
  5. Choose resolution — Use 480p for lower-cost generation or 768p for higher-resolution output.
  6. Choose generation mode — Select speed for faster generation or quality for higher-quality generation. Pricing depends on the selected mode and resolution.
  7. Set prompt upsampling — Use off, turbo, or max depending on how much prompt expansion you want.
  8. Set seed optional — Use a fixed seed for reproducible results, or omit it for random generation.
  9. Submit — Generate the final image-to-video output.

Pricing

Pricing is based on the requested duration, selected resolution, and generation mode.

ResolutionSpeed / secondQuality / second
480p$0.02$0.04
768p$0.035$0.075

Example Costs

Duration480p Speed480p Quality768p Speed768p Quality
5s$0.10$0.20$0.175$0.375
10s$0.20$0.40$0.35$0.75
15s$0.30$0.60$0.525$1.125

The default settings are 768p, speed, and 5 seconds, costing $0.175 per request.

Billing uses the requested duration, not the measured duration of the generated output. Generated audio is included. Prompt upsampling, seed selection, and supported image-conditioning inputs do not add separate charges.

Best Use Cases

  • Image animation — Turn a still image into a generated video.
  • Start-and-end-frame generation — Use image and last_image to guide both ends of the video.
  • Product and creative videos — Animate product images, campaign visuals, posters, or concept frames.
  • Character motion — Add motion, expression, or camera movement to a character or portrait image.
  • Creative prototyping — Test motion direction, pacing, and visual style from a fixed first frame.
  • Prompt iteration — Compare speed and quality generation modes and independently adjust prompt upsampling.

Pro Tips

  • Use a clear, high-quality first-frame image for stronger subject and composition control.
  • Add last_image when the final pose, framing, or scene state matters.
  • Write prompts that describe visible motion, not just visual style.
  • Include subject action, camera movement, lighting, mood, and scene progression.
  • Use mode=speed for faster, lower-cost iteration, or mode=quality when prioritizing output quality.
  • Use prompt_upsampler=off when you want the model to follow your original prompt more directly.
  • Use prompt_upsampler=max when the prompt is short and needs stronger expansion.
  • Use 480p for lower-cost tests and 768p for higher-resolution output.
  • Set a fixed seed when comparing prompt or parameter changes.

Notes

  • prompt and image are required.
  • duration supports values from 5 to 15 seconds.
  • The first-frame image determines the output canvas.
  • last_image is optional and is used for ending-frame guidance.
  • mode and prompt_upsampler are independent settings. mode controls the generation recipe and price; prompt_upsampler controls prompt expansion without changing the price.

Related Models

Note:This website uses AI models provided by third parties. Documentation prices are for reference and may be outdated. The Generate button shows an estimate; the final task charge prevails.

P Video 2 Pro Image To Video API — Quick start

Grab a WaveSpeedAI API key, then call POST https://api.wavespeed.ai/api/v3/pruna-ai/p-video-2-pro/image-to-video with your input as JSON. The endpoint returns a prediction id. Start polling the result endpoint around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. On completed, read output values from data.outputs. Examples for P Video 2 Pro Image To Video below.

HTTP example
set -euo pipefail

: "${WAVESPEED_API_KEY:?Set WAVESPEED_API_KEY}"

REQUEST_BODY=$(cat <<'JSON'
{
    "prompt": "A cinematic shot of a city at sunset, soft golden light",
    "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
    "duration": 5,
    "resolution": "768p",
    "mode": "speed",
    "prompt_upsampler": "turbo"
}
JSON
)

# 1. Submit the prediction.
SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  -X POST "https://api.wavespeed.ai/api/v3/pruna-ai/p-video-2-pro/image-to-video" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $WAVESPEED_API_KEY" \
  -d "$REQUEST_BODY")

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

# 2. Poll until the prediction finishes.
while true; do
  RESPONSE=$(curl --silent --show-error --fail-with-body "$RESULT_URL" \
    -H "Authorization: Bearer $WAVESPEED_API_KEY")
  RESULT=$(printf '%s' "$RESPONSE" | jq 'if has("data") then .data else . end')
  STATUS=$(printf '%s' "$RESULT" | jq -r '.status')
  case "$STATUS" in
    completed) printf '%s\n' "$RESULT" | jq '.outputs'; break ;;
    failed|cancelled|timeout|deleted) printf '%s\n' "$RESULT" | jq . >&2; exit 1 ;;
    *) sleep 2 ;;
  esac
done
Node.js example
const submitUrl = "https://api.wavespeed.ai/api/v3/pruna-ai/p-video-2-pro/image-to-video";
const apiKey = process.env.WAVESPEED_API_KEY;
if (!apiKey) throw new Error('Set WAVESPEED_API_KEY');

async function requestJson(url, options = {}) {
  const response = await fetch(url, options);
  if (!response.ok) throw new Error(await response.text());
  return response.json();
}

// 1. Submit the prediction.
const body = await requestJson(submitUrl, {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${apiKey}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
        "prompt": "A cinematic shot of a city at sunset, soft golden light",
        "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
        "duration": 5,
        "resolution": "768p",
        "mode": "speed",
        "prompt_upsampler": "turbo"
}),
});
const task = body.data ?? body;
if (!task.id) throw new Error("Submission response did not contain a prediction id");
const resultUrl = `https://api.wavespeed.ai/api/v3/predictions/${task.id}/result`;

// 2. Poll until the prediction finishes.
while (true) {
  const resultBody = await requestJson(resultUrl, {
    headers: { "Authorization": `Bearer ${apiKey}` },
  });
  const result = resultBody.data ?? resultBody;
  if (result.status === "completed") {
    console.log(result.outputs);
    break;
  }
  if (["failed", "cancelled", "timeout", "deleted"].includes(result.status)) throw new Error(JSON.stringify(result));
  await new Promise(resolve => setTimeout(resolve, 2000));
}
Python example
import json
import os
import time
from urllib.request import Request, urlopen

api_key = os.environ["WAVESPEED_API_KEY"]
headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
payload = {
    "prompt": "A cinematic shot of a city at sunset, soft golden light",
    "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
    "duration": 5,
    "resolution": "768p",
    "mode": "speed",
    "prompt_upsampler": "turbo"
}

def request_json(url, data=None):
    request = Request(url, data=data, headers=headers, method="POST" if data else "GET")
    with urlopen(request) as response:
        return json.load(response)

# 1. Submit the prediction.
body = request_json("https://api.wavespeed.ai/api/v3/pruna-ai/p-video-2-pro/image-to-video", json.dumps(payload).encode())
task = body.get("data", body)
if not task.get("id"):
    raise RuntimeError("Submission response did not contain a prediction id")
result_url = f"https://api.wavespeed.ai/api/v3/predictions/{task['id']}/result"

# 2. Poll until the prediction finishes.
while True:
    result_body = request_json(result_url)
    result = result_body.get("data", result_body)
    status = result.get("status")
    if status == "completed":
        print(result.get("outputs", []))
        break
    if status in {"failed", "cancelled", "timeout", "deleted"}:
        raise RuntimeError(result)
    time.sleep(2)

P Video 2 Pro Image To Video API — Frequently asked questions

What is the P Video 2 Pro Image To Video API?

P Video 2 Pro Image To Video is a Pruna Ai model for video generation from images, exposed as a REST API on WaveSpeedAI. Pruna P-Video-2-Pro Image-to-Video generates videos from input images with optional last-frame guidance, 480P / 768P output, generated audio, and explicit controls for duration, resolution, and draft mode. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing. You can call it programmatically or try it from the playground above.

How do I call the P Video 2 Pro Image To Video API?

POST your input parameters to the model's REST endpoint (shown in the API tab of this playground) with your WaveSpeedAI API key in the Authorization header. Submission returns a prediction ID. Poll the result endpoint starting around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. The playground generates Python, JavaScript, and cURL examples for submitting requests and polling results. Full request/response shape is documented at https://wavespeed.ai/docs/docs-api/pruna-ai/pruna-ai-p-video-2-pro-image-to-video.

How much does P Video 2 Pro Image To Video cost per run?

P Video 2 Pro Image To Video starts at $0.02 per run. That figure is the base price — the final charge scales with the parameters you set in the form (output size, length, count, references, or whatever knobs this model exposes), so a higher-quality or larger output costs more than a minimal one. The exact cost for your current input is shown live next to the Generate button before you submit, and the actual per-call charge is recorded on the prediction afterwards.

What inputs does P Video 2 Pro Image To Video accept?

Key inputs: `prompt`, `image`, `resolution`, `duration`, `seed`, `last_image`. The full JSON schema (types, defaults, allowed values) is rendered above the Generate button and mirrored in the API reference at https://wavespeed.ai/docs/docs-api/pruna-ai/pruna-ai-p-video-2-pro-image-to-video.

How do I get started with the P Video 2 Pro Image To Video API?

Sign up for a free WaveSpeedAI account to claim starter credits, copy your API key from /accesskey, then call the endpoint shown in the API tab of the playground. The playground also auto-generates a code sample in Python, JavaScript, or cURL for the parameters you've set.

Can I use P Video 2 Pro Image To Video outputs commercially?

Commercial usage rights depend on the model's license, set by its provider (Pruna Ai). Check the provider's applicable terms and WaveSpeedAI's Terms of Service before commercial use.

Pruna P-Video-2-Pro Image-to-Video API on WaveSpeedAI