English Arabic 简体中文 繁體中文 Français Deutsch 日本語 한국어 Português Русский Español

PixVerse V4.5 Quick Start for Text-to-Video and Image-to-Video Generation

By / / Video, API / 5 minutes of reading
PixVerse V4.5 Quick Start for Text-to-Video and Image-to-Video Generation
Table Of Contents
  1. When to Use This Quick Start
  2. Step 1: Get Your Novita API Key
  3. Step 2: Confirm the Endpoints
  4. Step 3: Send Your First T2V Request
  5. Step 4: Send Your First I2V Request
  6. Step 5: Poll for Results
  7. Step 6: Check Pricing and Limits
  8. Key Parameters
  9. Python Example — Full Async Workflow
  10. cURL Examples
  11. Troubleshooting
  12. FAQ

PixVerse V4.5 is available on Novita AI through two async endpoints: POST https://api.novita.ai/v3/async/pixverse-v4.5-t2v for text-to-video (T2V) and POST https://api.novita.ai/v3/async/pixverse-v4.5-i2v for image-to-video (I2V). Both follow the same two-step async pattern — submit a generation request, receive a task_id, then poll GET /v3/async/task-result until the status is TASK_STATUS_SUCCEED and the video URL is available. This guide gets you from zero to a working video URL for each mode.

When to Use This Quick Start

Use this guide when you need a verified working request before writing production logic around PixVerse V4.5.

T2V is the right path when your input is entirely text — a scene description, a storyboard caption, or a product prompt. I2V is for cases where you have a reference image and want PixVerse to animate it forward from that frame.

Worth knowing before you start:

  • Clips max out at 5 seconds at 1080p, or 8 seconds at 720p and below.
  • fast_mode: true speeds up generation and lowers cost but caps resolution at 720p.
  • The style preset parameter (anime, 3d_animation, clay, comic, cyberpunk) is documented as v3.5-only — test it against V4.5 before relying on it in production.
  • I2V image inputs must be jpg, jpeg, or png; maximum 10MB; minimum 300×300px; and an aspect ratio between 1:2.5 and 2.5:1.

This guide does not cover the PixVerse web interface, self-hosting, or fine-tuning. It covers the Novita AI-hosted API path only.

Step 1: Get Your Novita API Key

Create a Novita AI account and navigate to API key management. Generate a key and export it to your environment:

export NOVITA_API_KEY="your_api_key_here"

Keep the key out of version control, client-side bundles, and Docker image layers.

Step 2: Confirm the Endpoints

T2VI2V
Submission endpointPOST https://api.novita.ai/v3/async/pixverse-v4.5-t2vPOST https://api.novita.ai/v3/async/pixverse-v4.5-i2v
Result endpointGET https://api.novita.ai/v3/async/task-result?task_id=<id>GET https://api.novita.ai/v3/async/task-result?task_id=<id>
API referenceT2V docsI2V docs

The result endpoint is shared across all Novita AI async APIs. Once you understand the poll loop, it works the same way for every model.

Step 3: Send Your First T2V Request

Submit a generation with a prompt and your preferred aspect ratio. The defaults (aspect_ratio: "16:9", resolution: "540p", fast_mode: false) are a reasonable starting point:

curl -s -X POST https://api.novita.ai/v3/async/pixverse-v4.5-t2v \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A time-lapse of cherry blossoms falling in slow motion, soft morning light, cinematic 4K",
    "aspect_ratio": "16:9",
    "resolution": "720p"
  }'

A successful 200 response returns only:

{
  "task_id": "abc123..."
}

Save the task_id. Nothing else is returned at this stage — the video generation runs asynchronously.

Step 4: Send Your First I2V Request

I2V takes a starting image and animates it according to your prompt. The image_file field expects a base64-encoded string of the source image:

# Encode your image first
IMAGE_B64=$(base64 -w 0 /path/to/your/image.jpg)

curl -s -X POST https://api.novita.ai/v3/async/pixverse-v4.5-i2v \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"prompt\": \"Camera slowly pushes forward, light wind moves through the scene\",
    \"image_file\": \"$IMAGE_B64\",
    \"resolution\": \"720p\"
  }"

The response is the same shape as T2V:

{
  "task_id": "xyz789..."
}

Key image constraints to check before sending:

  • Format: jpg, jpeg, or png only
  • File size: max 10MB (check before encoding — base64 expands size by ~33%)
  • Minimum dimensions: 300×300px
  • Aspect ratio: between 1:2.5 and 2.5:1 (portrait to landscape extremes)

Step 5: Poll for Results

Poll the task result endpoint with the task_id returned from the submission step:

curl -s "https://api.novita.ai/v3/async/task-result?task_id=abc123..." \
  -H "Authorization: Bearer $NOVITA_API_KEY"

The task.status field cycles through these states:

StatusMeaning
TASK_STATUS_QUEUEDTask is waiting in the queue
TASK_STATUS_PROCESSINGGeneration is running
TASK_STATUS_SUCCEEDVideo is ready; URL is in the response
TASK_STATUS_FAILEDGeneration failed; check task.reason

Poll every 5–10 seconds. When TASK_STATUS_SUCCEED appears, the video URL will be in the response body. The task.eta field provides an estimated completion time in seconds, which you can use to schedule your first poll.

Step 6: Check Pricing and Limits

Novita AI’s published pricing for PixVerse V4.5 is $0.7 per 5-second clip (verified from Novita AI’s PixVerse product pages as of July 2026). Verify the current rate on the Novita AI pricing page before building any cost estimate.

fast_mode: true generates videos faster and at lower cost, but resolution is capped at 720p. It is useful for prototyping or batch preview generation where quality is secondary.

Rate limits scale by account tier. Check Novita AI rate limit documentation for current tier thresholds.

Key Parameters

T2V Parameters

ParameterTypeDefaultNotes
promptstring—Required. Max 2048 characters.
aspect_ratiostring16:916:9, 4:3, 1:1, 3:4, 9:16
resolutionstring540p360p, 540p, 720p, 1080p. 1080p requires fast_mode: false.
negative_promptstring—Max 2048 characters. Describe what to avoid.
fast_modebooleanfalseFaster and cheaper; caps at 720p.
stylestring—anime, 3d_animation, clay, comic, cyberpunk. Labeled v3.5-only — test before production use.
seedinteger—Set for reproducibility; outputs may still vary after model updates.

I2V Parameters

ParameterTypeDefaultNotes
promptstring—Required. Max 2048 characters.
image_filestring—Required. Base64-encoded jpg/jpeg/png. Max 10MB, min 300×300px, aspect ratio 1:2.5 to 2.5:1.
resolutionstring540pSame options as T2V.
negative_promptstring—Max 2048 characters.
fast_modebooleanfalseSame as T2V.
stylestring—Same as T2V.
seedinteger—Same as T2V.

Note: I2V does not take an aspect_ratio parameter — the output aspect ratio is derived from the input image.

Python Example — Full Async Workflow

This example covers both T2V and I2V submission plus the poll loop in one script:

import os
import time
import base64
import requests

API_KEY = os.environ["NOVITA_API_KEY"]
BASE_URL = "https://api.novita.ai/v3/async"

HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}


def submit_t2v(prompt: str, aspect_ratio: str = "16:9", resolution: str = "720p") -> str:
    resp = requests.post(
        f"{BASE_URL}/pixverse-v4.5-t2v",
        headers=HEADERS,
        json={
            "prompt": prompt,
            "aspect_ratio": aspect_ratio,
            "resolution": resolution,
        },
    )
    resp.raise_for_status()
    return resp.json()["task_id"]


def submit_i2v(prompt: str, image_path: str, resolution: str = "720p") -> str:
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode("utf-8")
    resp = requests.post(
        f"{BASE_URL}/pixverse-v4.5-i2v",
        headers=HEADERS,
        json={
            "prompt": prompt,
            "image_file": image_b64,
            "resolution": resolution,
        },
    )
    resp.raise_for_status()
    return resp.json()["task_id"]


def poll_result(task_id: str, interval: int = 8, timeout: int = 300) -> dict:
    deadline = time.time() + timeout
    while time.time() < deadline:
        resp = requests.get(
            f"{BASE_URL}/task-result",
            headers=HEADERS,
            params={"task_id": task_id},
        )
        resp.raise_for_status()
        data = resp.json()
        status = data.get("task", {}).get("status")
        if status == "TASK_STATUS_SUCCEED":
            return data
        if status == "TASK_STATUS_FAILED":
            reason = data.get("task", {}).get("reason", "unknown")
            raise RuntimeError(f"Task {task_id} failed: {reason}")
        time.sleep(interval)
    raise TimeoutError(f"Task {task_id} did not complete within {timeout}s")


if __name__ == "__main__":
    # Text-to-video
    t2v_task = submit_t2v(
        prompt="A lone lighthouse on a rocky coast at dusk, waves crashing, golden sky",
        aspect_ratio="16:9",
        resolution="720p",
    )
    print(f"T2V task submitted: {t2v_task}")
    t2v_result = poll_result(t2v_task)
    print("T2V result:", t2v_result)

    # Image-to-video — replace with a real image path
    # i2v_task = submit_i2v(
    #     prompt="Gentle wind moves through the scene, slow camera pull-back",
    #     image_path="./reference.jpg",
    #     resolution="720p",
    # )
    # print(f"I2V task submitted: {i2v_task}")
    # i2v_result = poll_result(i2v_task)
    # print("I2V result:", i2v_result)

cURL Examples

T2V with fast mode:

curl -s -X POST https://api.novita.ai/v3/async/pixverse-v4.5-t2v \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A hyperrealistic ocean wave cresting and breaking on shore, slow motion, golden hour",
    "aspect_ratio": "9:16",
    "resolution": "720p",
    "fast_mode": true,
    "negative_prompt": "blurry, low quality, watermark"
  }'

T2V with seed for reproducibility:

curl -s -X POST https://api.novita.ai/v3/async/pixverse-v4.5-t2v \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Neon-lit cyberpunk street at night, rain reflections, hovering vehicles",
    "aspect_ratio": "16:9",
    "resolution": "1080p",
    "seed": 42
  }'

Poll for result:

curl -s "https://api.novita.ai/v3/async/task-result?task_id=YOUR_TASK_ID" \
  -H "Authorization: Bearer $NOVITA_API_KEY"

Troubleshooting

400 Bad Request on I2V submission

Check image constraints first: format must be jpg/jpeg/png, size must be under 10MB before base64 encoding (the encoded payload will be ~33% larger), minimum 300×300px, and aspect ratio between 1:2.5 and 2.5:1. Landscape extremes (very wide or very tall images) will be rejected.

Task stays in TASK_STATUS_QUEUED for a long time

This is normal under high platform load. The task.eta field gives an estimate; poll accordingly rather than hammering the endpoint. If a task has not advanced after 10 minutes, check Novita AI’s status page or retry the submission.

TASK_STATUS_FAILED with no useful reason

Retry with a shorter, simpler prompt. Prompts with ambiguous motion instructions, contradictory scene descriptions, or characters performing impossible physics tend to fail. Negative prompts can also conflict with the main prompt if they’re too broad.

1080p not available in fast mode

fast_mode: true caps resolution at 720p. If you need 1080p, remove fast_mode or set it to false.

style parameter has no visible effect

The style parameter is documented as v3.5-only. In V4.5 requests it may be silently ignored or produce inconsistent results. Do not rely on it without testing your specific use case.

FAQ

What is the difference between T2V and I2V for PixVerse V4.5?

T2V generates a video clip entirely from a text prompt — no image input is needed. I2V takes a starting image and animates it forward according to the text prompt, using the image as the first frame. Use T2V for fully generated scenes; use I2V when you have a specific visual starting point you want to animate.

What video lengths does PixVerse V4.5 produce?

Clips are 5 seconds at 1080p and up to 8 seconds at resolutions of 720p and below. There is no duration parameter in the API — clip length is determined by the resolution you select.

Does the I2V endpoint infer aspect ratio from the image?

Yes. I2V has no aspect_ratio parameter. The output aspect ratio matches the input image. Make sure your image is cropped to the intended output ratio before submitting.

Can I submit T2V and I2V requests in parallel?

Yes. Each request returns its own independent task_id. You can submit multiple requests concurrently and poll them in parallel — no need to wait for one to complete before submitting the next.

How do I get consistent outputs across runs?

Set the seed parameter to the same integer. Keep in mind that seed-based reproducibility is not guaranteed across model version updates — store the video URL and the generation parameters together if you need to audit results later.

Is fast_mode suitable for production use?

It depends on your quality bar. fast_mode: true generates videos faster and costs less, but resolution is capped at 720p and quality is lower than standard mode. It is well-suited for preview generation, batch evaluation, and prototyping; use standard mode when output quality is the deciding factor.

Related Posts