3D rendered still image transforming into a video frame on a dark cinematic stage with ◆MODELLIX wordmark, amber key and cyan rim lighting, shallow depth of field

What PixVerse image-to-video actually does

PixVerse image-to-video takes a still image — a product photo, a character design, a storyboard frame — and turns it into a short video clip, driven by a text prompt that describes the motion you want. It runs on two models: V6 (the flagship, supporting text-to-video, image-to-video, transitions, and extensions) and C1 (cinematic-focused, stronger on style transfer and animation).

The output specs: up to 15 seconds per generation, resolutions from 360p to 1080p, and stereo audio if you enable it. V6 supports multiple aspect ratios for text-to-video and fusion modes, but image-to-video specifically outputs at the native ratio of your input image — aspect ratio control happens on the source image side, not in the generation call.

V6’s I2V endpoint also supports multi-clip generation (generate_multi_clip_switch) and an optional audio pass (generate_audio_switch) that produces ambient sound, voice, or effects synced to the visual output in a single generation. C1’s I2V works the same way but is tuned for cinematic aesthetics rather than general-purpose motion — it’s the pick when visual fidelity matters more than parameter flexibility.

If you need a broader overview of what PixVerse offers beyond I2V — the full model family, the consumer app vs API distinction, and how it stacks up against competitors — start with our PixVerse AI overview.

PixVerse I2V API: endpoints, authentication, and parameters

PixVerse’s image-to-video generation lives at the img/generate endpoint in the PixVerse Platform API. The workflow follows a standard media-generation pattern: upload your source image, submit the generation request with your parameters, poll for completion, then download the result.

The endpoint path is img/generate — PixVerse’s Platform API uses a standard base URL with Bearer token authentication. You generate your API key from the PixVerse Platform dashboard under API Keys. The full API reference and parameter tables live in the V6 model documentation.

Here are the parameters that matter for image-to-video generation with V6, as documented in the V6 model reference:

Parameter Type Required What it controls
model string Yes "v6" or "c1"
prompt string Yes Motion description, up to 5,000 characters
duration int Yes 1–15 seconds
quality string Yes "360p", "540p", "720p", or "1080p"
img_id int Yes The media ID returned by the upload endpoint
generate_audio_switch boolean No true to generate audio alongside video (default: false)
generate_multi_clip_switch boolean No true for multi-shot sequences in one generation (default: false)
seed int No 0–2,147,483,647 — set for reproducible output

The img_id parameter is the critical piece that distinguishes I2V from text-to-video. Before calling img/generate, you upload your source image to PixVerse’s servers via the media upload endpoint. That gives you a numeric media_id — pass it as img_id and the model conditions its output on your image.

PixVerse image-to-video API workflow: upload source image, get media_id, submit generation request with img_id, poll status, download video

Some parameters you might expect but won’t find on I2V: aspect_ratio is not available on img/generate — the output inherits your source image’s dimensions. If you need a specific aspect ratio, resize your image before uploading.

The seed parameter is worth calling out specifically. PixVerse uses a deterministic RNG when you set seed to the same value across calls with identical parameters — you’ll get the same output. This is essential for A/B testing prompts or building a pipeline where you need consistent results from the same inputs.

Image-to-video pricing: what a generation actually costs

PixVerse bills in credits. One credit costs $0.01 at standard top-up ($10 = 1,000 credits), with volume discounts on membership tiers. The PixVerse pricing documentation breaks down per-second costs by model, resolution, and audio toggle.

For V6 image-to-video, the credits-per-second table:

Resolution No audio With audio
360p 5 credits/sec 7 credits/sec
540p 7 credits/sec 9 credits/sec
720p 9 credits/sec 12 credits/sec
1080p 18 credits/sec 23 credits/sec

PixVerse markets its Starter pack at “$1 = 5 videos (V6, 720p, 5s, no audio).” At 9 credits/sec × 5 seconds = 45 credits per video, that’s 225 credits for $1 — or roughly $0.0044 per credit on the Starter pack, which is better than the standard $0.01 rate. The pricing page lists membership tiers up to Enterprise, so per-credit cost drops further with volume.

PixVerse V6 image-to-video credit cost table by resolution and audio setting

C1 costs slightly more: 10 credits/sec at 720p with no audio, 13 with audio. The higher cost reflects C1’s cinematic rendering — it’s tuned for visual quality over throughput.

One cost factor the pricing page doesn’t call out explicitly: failed generations don’t refund credits. If your prompt produces unusable output, or the model hits a content filter, those credits are gone. Budget for retries — most developers doing I2V at scale assume a 20–30% retry rate for prompt tuning.

For a full pricing breakdown across all PixVerse models (including V5.6, V5.5, lipsync, and avatar modes), see our PixVerse pricing guide.

Code example: generate an I2V video with cURL and Python

Here’s a complete cURL example that uploads an image, submits an I2V generation request, and polls for the result.

Step 1: Upload your source image.

1
2
3
curl -X POST "https://api.pixverse.ai/v1/media/upload" \
  -H "Authorization: Bearer $PIXVERSE_API_KEY" \
  -F "file=@product-shot.png"

The response returns a media_id. Save it — you’ll pass it as img_id in the generation request.

Step 2: Submit the image-to-video generation.

1
2
3
4
5
6
7
8
9
10
11
12
curl -X POST "https://api.pixverse.ai/v1/img/generate" \
  -H "Authorization: Bearer $PIXVERSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "v6",
    "prompt": "Slow dolly push-in on the product, soft studio lighting, reflective surface catches a highlight as the camera moves",
    "duration": 5,
    "quality": "720p",
    "img_id": 123456,
    "generate_audio_switch": false,
    "seed": 42
  }'

The response includes a task_id. Use it to poll for completion.

Step 3: Poll until the generation finishes.

1
2
curl -X GET "https://api.pixverse.ai/v1/task/$TASK_ID/status" \
  -H "Authorization: Bearer $PIXVERSE_API_KEY"

Status 1 means complete — the response body will contain a download URL for your video. Status 5 means still processing; wait a few seconds and poll again. Most 720p 5-second generations complete in 30–90 seconds.

Python equivalent. The same workflow in Python using only requests:

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
import requests
import time

API_KEY = "your-pixverse-api-key"
BASE = "https://api.pixverse.ai/v1"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

# Upload image
with open("product-shot.png", "rb") as f:
    r = requests.post(f"{BASE}/media/upload", headers=HEADERS, files={"file": f})
media_id = r.json()["media_id"]

# Submit I2V generation
payload = {
    "model": "v6",
    "prompt": "Slow dolly push-in on the product, soft studio lighting",
    "duration": 5,
    "quality": "720p",
    "img_id": media_id,
    "generate_audio_switch": False,
    "seed": 42
}
r = requests.post(f"{BASE}/img/generate", headers=HEADERS, json=payload)
task_id = r.json()["task_id"]

# Poll for completion
while True:
    r = requests.get(f"{BASE}/task/{task_id}/status", headers=HEADERS)
    data = r.json()
    if data["status"] == 1:
        print(f"Done: {data['output_url']}")
        break
    elif data["status"] != 5:
        print(f"Failed: {data}")
        break
    time.sleep(5)

This is the same pattern whether you’re calling PixVerse directly or through an aggregation layer — the upload→submit→poll→download loop is the standard for video generation APIs. For more on how video APIs handle the full request lifecycle (including webhooks and error recovery), read our guide to PixVerse text-to-video via API.

Accessing PixVerse image-to-video through an aggregation layer

You can call PixVerse’s I2V endpoint directly — as shown above — or through an API aggregation platform that hosts multiple video models behind a single key.

The direct path gives you the lowest per-credit cost (especially with PixVerse membership tiers) and access to the full model surface. The aggregation path gives you one API key that also unlocks Kling, Seedance, Hailuo, Veo, and 200+ other models — useful if you’re comparing output across providers or building a pipeline that picks the best model per prompt.

Modellix is one such aggregation layer that carries PixVerse V6 and C1. Two disclosures worth making upfront, since this is the Modellix blog: first, Modellix won’t be the cheapest source for any single model — buying PixVerse credits directly can undercut an aggregator’s per-second rate. What the single key buys is comparison and consolidated billing, not a floor price. Second, Modellix doesn’t carry PixVerse Growth Studio or Image Avatar — those are PixVerse-first-party products. It distributes the core video generation models through a unified REST API at per-second billing; PixVerse builds them.

The API workflow is identical — upload, submit, poll, download — with the same model, prompt, duration, and quality parameters. The difference is authentication: one key for everything instead of one key per provider.

If you’re evaluating PixVerse against alternatives before committing, see our PixVerse AI overview which covers Kling, Seedance, Hailuo, Vidu, Veo, and Runway with per-model breakdowns.

When I2V works well — and when it doesn’t

PixVerse image-to-video is strongest when the source image has clear subjects, defined edges, and an obvious motion path. A product on a clean background, a character in a neutral pose, a landscape with a horizon line — these give the model enough signal to animate convincingly. The seed parameter makes it practical for pipeline use: same image, same prompt, same seed = same output, every time.

It’s weaker when the source image is cluttered, when the motion you want is subtle (micro-expressions, slow atmospheric shifts), or when the subject needs to stay pixel-perfect while the background moves. PixVerse animates the whole frame — it doesn’t do selective motion masking where the subject stays frozen and only the background changes. If that’s what you need, Runway’s inpainting-based approach or Kling’s motion brush is a better fit.

The credit system also creates an invisible cost: you pay for failed generations. Most I2V developers budget for a 20–30% retry rate while tuning prompts. Start with short durations (3–5 seconds) and 540p while you’re dialing in your prompt, then scale to 1080p once the output is predictable.

For a deeper look at what PixVerse gets right and where it falls short — including the consumer app vs developer API split and how the credit math works across all models — read the PixVerse AI overview, and for a dollar-by-dollar comparison with other video models, see our guide to the cheapest AI APIs.