PixVerse API Guide: Features, Pricing & Code (2026)

PixVerse has built a name for itself in AI video generation on the strength of its motion quality and a useful set of camera and effect templates. If you are looking at building video generation into your own product, this guide walks through what the PixVerse API offers, what it costs, how to get access, and a working code example for generating your first clip.

What Is the PixVerse API

PixVerse generates video from text or from an existing image. The API runs on the same models as the consumer app, accessed through a separate developer platform. It is built for developers who want to submit generation jobs programmatically, poll for status, and retrieve finished clips — rather than clicking through a web interface.

There are two main models available through the API. V6 is the general-purpose model, supporting text-to-video, image-to-video, first-and-last-frame transitions, video extension, and reference-based generation. C1 is a newer model tuned for cinema-style action and combat scenes with more physically accurate motion; it also supports multi-panel storyboard-to-video generation but does not support video extension. Older versions going back to V3.5 remain available for teams with existing integrations.

Key Features

PixVerse V6 model and motion quality

V6 tops out at 1080p and clips up to 15 seconds long, though the full 15-second length is only available at 1080p. It supports inline audio generation and can produce multiple clips from a single job, which is handy when you want variations to choose from.

Camera control and templates

PixVerse includes a camera_movement field for directing shots (values like zoom in are shown in the official examples), along with a template system for trending effects. This means you are not limited to describing camera moves through the text prompt alone — a template-driven approach that sets PixVerse apart from more prompt-only competitors.

Lip sync and audio support

Beyond the core generation models, PixVerse offers standalone endpoints for lip sync (using either an external audio file or a built-in set of TTS voices), sound effects generation, and video restyling tools. If your pipeline needs a character speaking on screen, PixVerse can handle that directly rather than requiring a separate lip sync service. If you need a full text-to-speech voice for lip sync rather than just a built-in TTS voice, our ElevenLabs API guide covers the best options.

PixVerse API Pricing

Pricing runs on a credit system. Cost depends on resolution, model, clip length, and whether audio is included. As a rough reference, a 5-second 720p clip on V6 without audio costs 45 credits — around $0.45 depending on which credit pack or plan you are on.

There are two ways to pay. Pay-as-you-go credit packs start at $10 for 1,000 credits and scale up to $5,000 for 500,000 credits, with better rates at higher pack sizes. Subscription plans start at $100 a month for 15,000 credits, with higher tiers for larger volume. Rate limits are tied to your tier as well, measured by how many videos you can generate at the same time, so a subscription buys you more parallel generations in addition to more credits.

How to Get API Access

1. Create an account at platform.pixverse.ai using email, Google, Apple, or Discord.
2. Go to the API Keys section and create a new key. It is only shown once, so save it somewhere safe right away.
3. Every request needs an API-KEY header with your key, plus a unique Ai-trace-id header per request (reusing the same trace ID will block a new generation from starting).
4. Base URL for the API is https://app-api.pixverse.ai.

Code Example: Generating Your First Video

Here is a minimal Python example that submits a text-to-video job and polls until it finishes.

import requests
import uuid
import time

API_KEY = "your-api-key"
BASE_URL = "https://app-api.pixverse.ai"
HEADERS = {
    "API-KEY": API_KEY,
    "Ai-trace-id": str(uuid.uuid4()),
    "Content-Type": "application/json",
}

payload = {
    "aspect_ratio": "16:9",
    "duration": 5,
    "model": "v6",
    "quality": "720p",
    "prompt": "A neon-lit city street in the rain, cinematic camera pan",
    "negative_prompt": "blurry, low quality",
    "seed": 0,
    "water_mark": False,
}

resp = requests.post(
    f"{BASE_URL}/openapi/v2/video/text/generate",
    headers=HEADERS, json=payload
).json()
video_id = resp["Resp"]["video_id"]

# Poll for the result. Status codes: 1 = success, 5 = generating, 7 = moderation failed, 8 = failed
while True:
    status_headers = {"API-KEY": API_KEY, "Ai-trace-id": str(uuid.uuid4())}
    r = requests.get(
        f"{BASE_URL}/openapi/v2/video/result/{video_id}",
        headers=status_headers
    ).json()
    status = r["Resp"]["status"]
    if status == 1:
        print("Video ready:", r["Resp"]["url"])
        break
    elif status in (7, 8):
        raise RuntimeError(f"Generation failed, status={status}")
    time.sleep(5)

For image-to-video, upload your source image first through the upload image endpoint to get an image ID, then submit that ID along with your prompt to the image-to-video generation endpoint instead of the text one. For a broader comparison of image-to-video tools, see our guide to the best image-to-video APIs.

PixVerse vs Other AI Video APIs

Kling AI tends to be the cheapest option per second of generated video and is popular for e-commerce and social content. Runway leads on camera direction tooling, with dedicated camera motion presets, but costs more per second — especially at the higher end of its model lineup. Luma's Ray 2 sits in between on price and is known for physically plausible motion and keyframe control. Pika is another option worth considering, particularly for stylised or animated content.

PixVerse holds its own on price at 720p with the V6 model, competitive with Kling, and its C1 model carves out a niche for action and combat scenes that the others do not specifically target. If your product needs video generation alongside other AI capabilities like image generation or voice, a unified API like Apiframe can simplify things, since it gives you one integration for multiple video models including Kling, Runway, and others, rather than a separate key and SDK for each vendor.