Seedance 2.5 telah hadir | Coba di Video Generator →

pixverse/

PixVerse C1 generates smooth transition videos between two images with flexible duration (1-15s), multiple resolutions up to 1080p, and optional native audio generation. Ready-to-use REST inference API, best performance, no cold starts, affordable pricing.

image-to-video
Input

Siap

$0.1per run·~10 / $1

Selanjutnya:

ContohLihat semua

She slowly rises from her crouch, turning her head with predatory precision toward a target below. Her hood falls back. Rain streaks past the camera. She straightens to full height, weapon drawn in one fluid motion. Camera slowly pushes in as she reaches the edge. Cinematic slow motion, rain particles, zero dialogue, score-driven tension.

Model Terkait

README

PixVerse C1 Transition

PixVerse C1 Transition generates a smooth, cinematic video transition between two images. Upload a start frame and an end frame, describe how the scene should transform — the model produces a natural, motion-consistent clip that flows seamlessly from one image to the other.

Why Choose This?

  • Start-to-end frame transitions Generates a coherent video that naturally bridges two distinct images with smooth, believable motion.

  • Prompt-guided transformation Describe how the transition should unfold — scene changes, camera movements, environmental shifts, and more.

  • Eight aspect ratio options Supports 16:9, 9:16, 1:1, 4:3, 3:4, 3:2, 2:3, and 21:9 for any platform or format.

  • Four resolution tiers Generate from 360p up to 1080p to match your quality and delivery requirements.

  • Optional native audio generation Enable generate_audio_switch to produce synchronized ambient sound alongside the transition.

  • Extended duration Generate clips from 1 to 15 seconds for full creative control over transition length.

Parameters

ParameterRequiredDescription
promptYesText description of the desired transition and scene transformation.
imageYesURL of the start frame image.
end_imageYesURL of the end frame image to transition toward.
aspect_ratioNoOutput aspect ratio. Options: 16:9 (default), 4:3, 1:1, 3:4, 9:16, 2:3, 3:2, 21:9.
resolutionNoOutput resolution: 360p, 540p, 720p (default), or 1080p.
durationNoClip length in seconds. Range: 1–15. Default: 5.
generate_audio_switchNoWhether to generate native audio for the video. Default: off.

How to Use

  1. Write your prompt — describe how the transition should unfold between the two frames.
  2. Upload your start image — provide the URL of the opening frame.
  3. Upload your end image — provide the URL of the target frame to transition toward.
  4. Select aspect ratio — choose the format that fits your target platform.
  5. Select resolution — 360p for fastest/lowest cost, 720p for standard, 1080p for highest quality.
  6. Set duration — choose between 1 and 15 seconds.
  7. Enable audio (optional) — check generate_audio_switch to generate synchronized native audio.
  8. Submit — generate, preview, and download your transition video.

Pricing

Duration360p / 540p720p1080p
5s$0.50$1.00$2.00
10s$1.00$2.00$4.00
15s$1.50$3.00$6.00

Billing Rules

  • 360p / 540p: $0.10 per second
  • 720p: $0.20 per second
  • 1080p: $0.40 per second
  • Audio surcharge: +$0.10 flat fee when generate_audio_switch is enabled

Best Use Cases

  • Scene transitions — Bridge two distinct environments or visual states with a natural cinematic transition.
  • Before & after content — Create compelling before-and-after reveal clips for social media.
  • Seasonal & atmospheric changes — Shift between seasons, times of day, or weather conditions from the same scene.
  • Marketing & advertising — Transition between product states or campaign visuals for polished ad content.
  • Creative storytelling — Connect two visual moments with a smooth, motioned narrative bridge.

Pro Tips

  • Use images of the same scene or subject from different states for the most natural transition results.
  • Be specific in your prompt about what changes between the two frames — lighting, season, atmosphere, or subject state.
  • Use 360p to test your transition concept before committing to a 1080p final render.
  • Enable audio for transitions with strong environmental context like nature scenes, city environments, or action sequences.

Notes

  • prompt, image, and end_image are all required fields.
  • Ensure image URLs are publicly accessible.
  • Please follow PixVerse's content usage policies when crafting prompts.

Related Models

Catatan:Situs web ini menggunakan model AI yang disediakan oleh pihak ketiga. Harga dokumentasi hanya sebagai referensi dan dapat kedaluwarsa. Tombol Generate menampilkan perkiraan; tagihan akhir tugas yang berlaku.

Pixverse C1 Transition API — Quick start

Grab a WaveSpeedAI API key, then call POST https://api.wavespeed.ai/api/v3/pixverse/pixverse-c1/transition 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 Pixverse C1 Transition 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",
    "end_image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
    "aspect_ratio": "16:9",
    "resolution": "720p",
    "duration": 5,
    "generate_audio_switch": false
}
JSON
)

# 1. Submit the prediction.
SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  -X POST "https://api.wavespeed.ai/api/v3/pixverse/pixverse-c1/transition" \
  -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=$(printf '%s' "$TASK" | jq -r '.urls.get // empty')
if [ -z "$RESULT_URL" ]; then
  RESULT_URL="https://api.wavespeed.ai/api/v3/predictions/$PREDICTION_ID/result"
fi

# 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) printf '%s\n' "$RESULT" | jq . >&2; exit 1 ;;
    created|processing) sleep 2 ;;
    *) printf 'Unexpected status: %s
' "$STATUS" >&2; exit 1 ;;
  esac
done
Node.js example
const submitUrl = "https://api.wavespeed.ai/api/v3/pixverse/pixverse-c1/transition";
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",
        "end_image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
        "aspect_ratio": "16:9",
        "resolution": "720p",
        "duration": 5,
        "generate_audio_switch": false
}),
});
const task = body.data ?? body;
if (!task.id) throw new Error("Submission response did not contain a prediction id");
const resultUrl = task.urls?.get ||
  `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"].includes(result.status)) throw new Error(JSON.stringify(result));
  if (!["created", "processing"].includes(result.status)) throw new Error("Unexpected status: " + result.status);
  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",
    "end_image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
    "aspect_ratio": "16:9",
    "resolution": "720p",
    "duration": 5,
    "generate_audio_switch": False
}

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/pixverse/pixverse-c1/transition", 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 = task.get("urls", {}).get("get") or 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"}:
        raise RuntimeError(result)
    if status not in {"created", "processing"}:
        raise RuntimeError(f"Unexpected status: {status}")
    time.sleep(2)

Pixverse C1 Transition API — Frequently asked questions

What is the Pixverse C1 Transition API?

Pixverse C1 Transition is a Pixverse model for video generation from images, exposed as a REST API on WaveSpeedAI. PixVerse C1 generates smooth transition videos between two images with flexible duration (1-15s), multiple resolutions up to 1080p, and optional native audio generation. Ready-to-use REST inference API, best performance, no cold starts, affordable pricing. You can call it programmatically or try it from the playground above.

How do I call the Pixverse C1 Transition 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 production-oriented Python, JavaScript, and cURL examples with timeouts, transient-error handling, and safe GET retries. Full request/response shape is documented at https://wavespeed.ai/docs/docs-api/pixverse/pixverse-pixverse-c1-transition.

How much does Pixverse C1 Transition cost per run?

Pixverse C1 Transition starts at $0.10 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 Pixverse C1 Transition accept?

Key inputs: `prompt`, `image`, `aspect_ratio`, `resolution`, `duration`, `end_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/pixverse/pixverse-pixverse-c1-transition.

How long does Pixverse C1 Transition take to generate?

Median end-to-end generation time on WaveSpeedAI is around 46 seconds per request, based on recent successful runs. Queue time varies with global demand; live status is visible in the prediction record.

Can I use Pixverse C1 Transition outputs commercially?

Commercial usage rights depend on the model's license, set by its provider (Pixverse). The license summary appears on the model card above; see WaveSpeedAI's Terms of Service for platform-level conditions.

Pixverse C1 Transition | Fast Image-to-Video API on WaveSpeedAI