Dark photorealistic 3D stage with ◆MODELLIX cyan wordmark. Bold white title PixVerse API. Floating video frames with amber key light and cyan rim highlights, shallow depth of field.

What the PixVerse API actually does (and doesn’t do)

If you search “pixverse api” the top results are PixVerse’s own product pages — feature lists, model showcases, a GitHub MCP repo. What you won’t find is a developer guide that walks you from zero to a working video generation pipeline with real code and real pricing.

Here’s the short version of what the API gives you:

Capability Models What it does
Text-to-video V5, V6 Generate video from a text prompt. 5s or 8s output.
Image-to-video V5, V6 Animate a still image. Add motion, camera movement, effects.
Video reference (V6 only) V6 Feed in a reference video and the model follows its motion, composition, and style.
Multi-shot video C1 Turn storyboards or multi-image sequences into coherent clips with scene transitions.
Lip sync V6 Sync mouth movements to an audio track. Combine with TTS for talking-head video.
Video extension V5, V6 Extend an existing clip beyond its original length.
Motion control V6 Specify camera movement direction, speed, and focal point.
Sound effects V6 Generate audio synchronized to video content — footsteps, ambient noise, action sounds.

Resolution goes up to 1080p across all models. Aspect ratios cover 16:9, 9:16, 1:1, and several in-between — so the same prompt can produce a YouTube landscape clip, a TikTok vertical, or a square Instagram post without reformatting.

What the API doesn’t do: generate still images (it’s video-only), handle real-time streaming (it’s async batch generation), or output 4K. It also doesn’t generate audio from scratch — the sound effects feature syncs audio to video content but doesn’t do standalone audio generation.

PixVerse model capabilities comparison matrix showing V5, V6, C1, and R1 features side by side

PixVerse model lineup across V5, V6, C1, and R1 — each optimized for different video generation tasks. V6 is the current flagship with video reference and sound effects. C1 handles multi-shot storyboard sequences.

If you’re evaluating PixVerse alongside other video APIs for your product, you’re probably asking three things: how do I get a key, what’s the cheapest way to run it, and which model should I actually use. The rest of this guide answers those in order.

One disclosure before we get into code: we run Modellix, an API aggregator that offers PixVerse models alongside 210+ other image and video models through a single API key. We have a commercial interest. Every fact here about PixVerse’s own API comes from their public platform docs and API documentation, verified July 30, 2026. Where we couldn’t verify something independently, we say so.

Getting your PixVerse API key — the three paths

There are three ways to get programmatic access to PixVerse models. The path you pick depends on whether you need PixVerse exclusively or want PixVerse as part of a broader model stack.

Path 1: PixVerse official platform

Go to platform.pixverse.ai and sign up for a developer account. You get an API key from the dashboard. PixVerse’s API uses credit-based billing — you buy credit packs, and each generation consumes credits based on model, resolution, duration, and whether you’re using video reference (which doubles the credit cost).

The official API gives you the deepest feature access — lip sync, sound effects, video reference, and motion control are all available. The tradeoff is billing complexity: credits are not dollars, and the credit-per-second math changes across models and resolutions.

Path 2: Modellix unified API key

If you’re already using other AI models in your stack — image generation, other video models, or planning to switch between Kling, Seedance, Hailuo, and PixVerse for different use cases — Modellix gives you one API key that covers all of them. No credit packs to buy, no per-model key management, no separate billing dashboards. You can browse the full PixVerse model catalog on Modellix to see which models are available, including V6 text-to-video, V6 image-to-video, video reference, lip sync, and more.

Pricing is per-second, not per-credit, and every call is logged with input, output, cost, and latency — useful when you’re comparing model performance across providers. Modellix pricing is public and searchable by model and resolution.

1
2
3
4
5
# Modellix: one key for PixVerse + 210+ other models
curl -X POST https://api.modellix.ai/v1/pixverse/v6-t2v/async \
  -H "Authorization: Bearer $MODELLIX_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "a cat walking through a neon-lit Tokyo alley at night", "duration": 5}'

Path 3: PixVerse MCP server (for AI agent workflows)

PixVerse maintains an official MCP server on GitHub. If you’re building AI agents that need video generation — Claude Code plugins, Cursor extensions, custom agent pipelines — the MCP server gives you PixVerse API access through natural language prompts.

1
2
3
4
# Clone and configure the MCP server
git clone https://github.com/PixVerseAI/PixVerse-MCP
cd PixVerse-MCP
# Add your API key to the MCP client config

The MCP path still requires API credits purchased separately — it’s an interface layer, not a free tier.

Which path should you pick? Official if PixVerse is your only model and you’re comfortable with credit-based billing. MCP if you’re building agent workflows. Modellix if you need PixVerse alongside other models with transparent per-second billing and don’t want to manage multiple API keys. The code examples in the next section work with any of the three — just swap the endpoint and auth header.

Your first PixVerse API call — authentication, request, and polling

PixVerse video generation is asynchronous. You submit a job, get a task ID, poll for completion, then retrieve the video URL. Here’s the full lifecycle in three languages.

Step 1: Submit the generation request

The Modellix endpoint shown below is one access path — the pattern is identical whether you’re calling PixVerse directly or through an aggregator. Here’s the Modellix version first, then a PixVerse-direct example for comparison.

Via Modellix (cURL):

1
2
3
4
5
6
7
8
9
curl -X POST https://api.modellix.ai/v1/pixverse/v6-t2v/async \
  -H "Authorization: Bearer $MODELLIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "drone shot flying over a misty mountain lake at sunrise, cinematic lighting",
    "duration": 5,
    "aspect_ratio": "16:9",
    "resolution": "1080p"
  }'

Response:

1
{"task_id": "pixv_8f3a2b1c", "status": "processing"}

Python:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import requests

response = requests.post(
    "https://api.modellix.ai/v1/pixverse/v6-t2v/async",
    headers={
        "Authorization": f"Bearer {MODELLIX_API_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "prompt": "drone shot flying over a misty mountain lake at sunrise, cinematic lighting",
        "duration": 5,
        "aspect_ratio": "16:9",
        "resolution": "1080p"
    }
)

task = response.json()
task_id = task["task_id"]   # e.g., "pixv_8f3a2b1c"

Node.js:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const response = await fetch("https://api.modellix.ai/v1/pixverse/v6-t2v/async", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${MODELLIX_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    prompt: "drone shot flying over a misty mountain lake at sunrise, cinematic lighting",
    duration: 5,
    aspect_ratio: "16:9",
    resolution: "1080p"
  })
});

const { task_id } = await response.json();

Step 2: Poll for completion

Video generation takes 30 seconds to 2 minutes depending on resolution, duration, and queue depth. Poll the task endpoint every 5-10 seconds.

Via PixVerse directly (Python):

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

# PixVerse direct API — replace with your own key
PIXVERSE_KEY = "your-pixverse-api-key"
PIXVERSE_BASE = "https://api.pixverse.ai/openapi/v2"

# Submit
resp = requests.post(
    f"{PIXVERSE_BASE}/video/t2v/generate",
    headers={"Authorization": f"Bearer {PIXVERSE_KEY}", "Content-Type": "application/json"},
    json={"model": "v6", "prompt": "drone shot flying over a misty mountain lake at sunrise", "duration": 5, "resolution": "1080p"}
)
task_id = resp.json()["data"]["video_id"]

# Poll
while True:
    status = requests.get(
        f"{PIXVERSE_BASE}/video/status",
        headers={"Authorization": f"Bearer {PIXVERSE_KEY}"},
        params={"video_id": task_id}
    ).json()
    if status["data"]["status"] == "completed":
        video_url = status["data"]["video_url"]
        break
    elif status["data"]["status"] in ("failed", "review_failed"):
        raise Exception(f"Generation failed: {status['data'].get('error')}")
    time.sleep(5)

Via Modellix (Python):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import time

while True:
    status_resp = requests.get(
        f"https://api.modellix.ai/v1/tasks/{task_id}",
        headers={"Authorization": f"Bearer {MODELLIX_API_KEY}"}
    )
    status = status_resp.json()
    
    if status["status"] == "completed":
        video_url = status["output"]["video_url"]
        break
    elif status["status"] == "failed":
        raise Exception(f"Generation failed: {status.get('error')}")
    
    time.sleep(5)

Step 3: Use the video

The video_url is a signed URL valid for 7 days. Download it immediately if you need persistent storage:

1
curl -O "$VIDEO_URL"
API request lifecycle: submit generation → receive task_id → poll status endpoint → completed → download video URL

The PixVerse API lifecycle: submit a generation job, poll for completion with exponential backoff, retrieve the signed video URL on success. Videos are available for 7 days — download immediately for persistent storage.

Image-to-video: same pattern, different input

For image-to-video, upload your source image first, then reference it in the generation request:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Step 1: Upload image
with open("input_frame.png", "rb") as f:
    upload_resp = requests.post(
        "https://api.modellix.ai/v1/media/files",
        headers={"Authorization": f"Bearer {MODELLIX_API_KEY}"},
        files={"file": f}
    )
image_id = upload_resp.json()["file_id"]

# Step 2: Generate video from image
response = requests.post(
    "https://api.modellix.ai/v1/pixverse/v6-i2v/async",
    headers={
        "Authorization": f"Bearer {MODELLIX_API_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "image_id": image_id,
        "prompt": "gentle camera pan right, subtle motion in the water",
        "duration": 5
    }
)
# Then poll as above

PixVerse API pricing — what you actually pay per video

The #1 question in the “People Also Ask” box for “pixverse api” is “How much does the PixVerse API cost?” The answer depends entirely on which access path you use. We have a full breakdown of PixVerse’s credit system and real per-second costs if you want the complete cross-provider comparison — but here’s the short version:

Provider Billing unit 5s 1080p video 8s 1080p video Monthly minimum Notes
PixVerse official Credits ~$0.75–$1.25 (estimated) ~$1.20–$2.00 None (credit packs) Credit cost varies by model and features; video reference doubles credits
Together AI Per video $0.30 N/A (V5 only, 5s max) None Fastest and cheapest; only V5, no video reference or lip sync
Atlas Cloud Per second ~$0.125 ~$0.20 None Good model coverage; per-second pricing
Modellix Per second See pricing page Same rate None All PixVerse models; pricing shown per model/resolution on pricing page

PixVerse’s official credit system makes apples-to-apples comparison difficult because credit consumption varies: 1080p costs more than 720p, video reference doubles credits, and different models have different base rates. The aggregator paths (Together AI, Atlas Cloud, Modellix) all use per-video or per-second pricing, which is more predictable.

If you’re generating hundreds of videos per month, the aggregator per-second model usually comes out ahead — no credit math, no leftover credits expiring, no surprise bills when you enable video reference on a 1080p render.

PixVerse API pricing comparison across official credits, Together AI, Atlas Cloud, and Modellix — per-video cost estimates for different resolutions and durations

PixVerse API pricing across access paths. Official credits are model-and-resolution-dependent. Aggregator paths use per-second or per-video pricing. Actual Modellix rates are on the public pricing page — check the current per-second rate for pixverse/v6-t2v at your target resolution.

Is there a free tier? PixVerse’s consumer web app offers 3 free trial generations. For the API specifically, PixVerse does not publish a free tier. Some aggregators offer trial credits — check each platform’s current new-user terms. Modellix offers a top-up discount on first deposit rather than free generations. Note that PixVerse’s consumer web app adds a watermark to free-tier videos, and some aggregator paths may include watermarking at lower pricing tiers — check each provider’s terms if watermark-free output matters for your use case.

V5 vs V6 vs C1 — which PixVerse model should you use?

If you’re building a product, you don’t want to call the wrong model and burn budget on features you don’t need. Here’s the decision logic:

Use V6 for most new projects. It’s the current flagship: text-to-video, image-to-video, video reference, lip sync, motion control, and sound effects in one model. If your product needs any of these — especially video reference (feeding in a reference clip and having V6 match its motion and composition) — V6 is the only option.

Use V5 if you need the lowest per-video cost and don’t need V6’s advanced features. V5 does text-to-video and image-to-video at lower credit/per-second rates. If you’re generating high volumes of straightforward clips at 720p, V5 will be cheaper per video. Together AI only offers V5 for this reason — it’s the cost-optimized path.

Use C1 for multi-shot storyboard sequences. If you have a series of images (storyboard frames, product angles, scene progression) and want them turned into one coherent video with transitions, C1 is purpose-built for this. It’s not a general-purpose model — don’t use it for single-prompt text-to-video.

R1 is PixVerse’s newest model (launched June 2026). It’s positioned as a reasoning-enhanced video model that handles complex, multi-step prompts. As of July 2026, R1 availability through third-party aggregators is still rolling out — check the Modellix model catalog for current availability.

Model Best for Tradeoff
V6 General-purpose video gen with advanced features (video reference, lip sync, motion control) Higher cost per second than V5
V5 High-volume straightforward text-to-video at lower cost No video reference, no lip sync, no sound effects
C1 Storyboard-to-video, multi-shot sequences Not for single-prompt generation
R1 Complex multi-step prompts, reasoning-heavy generation Newest model; aggregator availability varies

Production deployment — async jobs, webhooks, and error handling

The polling loop from the “first API call” section works for development, but here’s what changes when you go to production:

Use webhooks instead of polling

Polling burns requests and adds latency. PixVerse’s API and most aggregator endpoints support webhook callbacks — you pass a webhook_url in the generation request, and the platform POSTs the result to your endpoint when the video is ready.

1
2
3
4
5
6
7
8
9
response = requests.post(
    "https://api.modellix.ai/v1/pixverse/v6-t2v/async",
    headers={"Authorization": f"Bearer {MODELLIX_API_KEY}"},
    json={
        "prompt": "...",
        "duration": 5,
        "webhook_url": "https://your-app.com/api/video-callback"
    }
)

Your webhook endpoint receives a POST with the task_id, status, and output.video_url — no polling needed.

Handle rate limits and concurrency

PixVerse official and aggregator APIs have rate limits and concurrency caps. At Modellix, your concurrent task limit and requests-per-minute scale with your top-up tier — from 10 concurrent tasks at the $10 tier up to 100 at $1,000. If you hit the limit, you get a 429 Too Many Requests.

1
2
3
4
5
6
7
8
from tenacity import retry, wait_exponential

@retry(wait=wait_exponential(multiplier=2, min=5, max=60))
def generate_video(prompt):
    response = requests.post(...)
    if response.status_code == 429:
        raise RateLimitError("Back off and retry")
    return response.json()["task_id"]

Track costs per generation

Every Modellix API call returns cost data in the response headers and the task status endpoint. Log this per-generation so you can track which prompts, models, and resolutions are driving your bill:

1
2
curl -s -H "Authorization: Bearer $MODELLIX_KEY" \
  "https://api.modellix.ai/v1/tasks/$TASK_ID" | jq '{status, cost, duration, model}'

Handle batch generation

If you need to generate dozens or hundreds of videos — for A/B testing creative variants, localizing a single video into multiple languages, or processing a queue of user-submitted prompts — you’ll hit concurrency limits quickly. Structure your worker to respect your tier’s concurrent task cap:

1
2
3
4
5
6
7
8
9
10
11
12
import asyncio
from concurrent.futures import ThreadPoolExecutor

MAX_CONCURRENT = 10  # match your tier

def generate_one(prompt):
    resp = requests.post("https://api.modellix.ai/v1/pixverse/v6-t2v/async", ...)
    return resp.json()["task_id"]

with ThreadPoolExecutor(max_workers=MAX_CONCURRENT) as executor:
    task_ids = list(executor.map(generate_one, prompts))
# Then poll all task_ids in a single batch loop

For very high volumes (thousands of videos per day), add a queue system (Redis, RabbitMQ, or SQS) with backpressure — submit at your concurrency cap, poll completed tasks, and feed new work as slots open.

Error handling: what to expect

Common failure modes and how to handle them:

  • Content moderation rejection (HTTP 400): The prompt or image triggered a safety filter. Log the prompt for review; don’t retry with the same input.
  • Server-side failure (HTTP 500): The model failed to render. Retry once — transient GPU errors happen. If it fails twice, the prompt may be malformed.
  • Timeout (no response in 5 minutes): Check the task status once, then alert your ops channel. Long queues during peak hours are rare but happen.

For the full error code reference, see the Modellix API docs — every error code includes a description, the scenario that triggers it, and whether it’s safe to retry.

Modellix vs direct PixVerse API — when to use which

You’ve now seen both paths working. Here’s when each makes sense:

Use PixVerse’s official API directly when:

  • PixVerse is the only AI model in your stack
  • You need the absolute latest features on day one (new model launches, beta features)
  • You’re comfortable with credit-based billing and per-model key management

Use Modellix when:

  • You use multiple AI video or image models and want one API key, one integration, one bill
  • You want per-second pricing with per-call cost logging — transparent and auditable
  • You want to A/B test PixVerse against Kling, Seedance, Hailuo, or other models without rewriting integration code for each provider — our PixVerse alternatives comparison covers how PixVerse stacks up against these models feature-by-feature
  • You need observability: every call logged with input, output, cost, and latency

The integration code you write for one path ports to the other with minimal changes — the API patterns (async submit → poll → retrieve) are structurally identical. The real difference is operational overhead: one key and one pricing model for your entire media generation stack, versus managing separate keys, billing systems, and error-handling logic for each model provider.

If you’re evaluating PixVerse alongside other video APIs and want to run a fair comparison, the Modellix unified endpoint makes that straightforward — same prompt, same resolution, same code, different model name in the URL path.

Pricing and model availability verified July 30, 2026. AI video generation pricing changes frequently — check each provider’s current pricing page before committing to a volume integration. PixVerse model features and capabilities from PixVerse Platform docs and developer documentation.