PixVerse V4.5 Schnellstart für Text-zu-Video- und Bild-zu-Video-Generierung

PixVerse V4.5 ist auf Novita AI über zwei asynchrone Endpunkte verfügbar: POST https://api.novita.ai/v3/async/pixverse-v4.5-t2v für Text-zu-Video (T2V) und POST https://api.novita.ai/v3/async/pixverse-v4.5-i2v für Bild-zu-Video (I2V). Beide folgen dem gleichen zweistufigen asynchronen Muster – senden Sie eine Generierungsanfrage, erhalten Sie eine task_id, dann fragen Sie GET /v3/async/task-result ab, bis der Status TASK_STATUS_SUCCEED ist und die Video-URL verfügbar ist. Diese Anleitung bringt Sie von null zu einer funktionierenden Video-URL für jeden Modus.

Wann dieser Schnellstart verwendet werden sollte

Verwenden Sie diese Anleitung, wenn Sie eine verifizierte funktionierende Anfrage benötigen, bevor Sie Produktionslogik für PixVerse V4.5 schreiben.

T2V ist der richtige Weg, wenn Ihre Eingabe vollständig Text ist – eine Szenenbeschreibung, eine Storyboard-Bildunterschrift oder ein Produkt-Prompt. I2V ist für Fälle, in denen Sie ein Referenzbild haben und möchten, dass PixVerse es von diesem Frame aus animiert.

Wissenswertes vor dem Start:

• Clips maximal 5 Sekunden bei 1080p oder 8 Sekunden bei 720p und darunter.
• fast_mode: true beschleunigt die Generierung und senkt die Kosten, begrenzt aber die Auflösung auf 720p.
• Der style-Parameter (anime, 3d_animation, clay, comic, cyberpunk) ist als nur für v3.5 dokumentiert – testen Sie ihn gegen V4.5, bevor Sie sich im Produktivbetrieb darauf verlassen.
• I2V-Bildeingaben müssen jpg, jpeg oder png sein; maximal 10 MB; mindestens 300×300 Pixel; und ein Seitenverhältnis zwischen 1:2,5 und 2,5:1.

Diese Anleitung behandelt nicht die PixVerse-Weboberfläche, Self-Hosting oder Feintuning. Sie deckt nur den von Novita AI gehosteten API-Pfad ab.

Schritt 1: Holen Sie sich Ihren Novita-API-Schlüssel

Erstellen Sie ein Novita AI-Konto und navigieren Sie zur API-Schlüsselverwaltung. Generieren Sie einen Schlüssel und exportieren Sie ihn in Ihre Umgebung:

export NOVITA_API_KEY="your_api_key_here"

Halten Sie den Schlüssel aus der Versionsverwaltung, clientseitigen Bundles und Docker-Image-Ebenen fern.

Schritt 2: Bestätigen Sie die Endpunkte

	T2V	I2V
Übermittlungsendpunkt	POST https://api.novita.ai/v3/async/pixverse-v4.5-t2v	POST https://api.novita.ai/v3/async/pixverse-v4.5-i2v
Ergebniseidpunkt	GET https://api.novita.ai/v3/async/task-result?task_id=<id>	GET https://api.novita.ai/v3/async/task-result?task_id=<id>
API-Referenz	T2V-Dokumentation	I2V-Dokumentation

Der Ergebniseidpunkt wird von allen asynchronen Novita AI APIs gemeinsam genutzt. Sobald Sie die Abrufschleife verstanden haben, funktioniert sie für jedes Modell gleich.

Schritt 3: Senden Sie Ihre erste T2V-Anfrage

Senden Sie eine Generierung mit einem Prompt und Ihrem bevorzugten Seitenverhältnis. Die Standardwerte (aspect_ratio: "16:9", resolution: "540p", fast_mode: false) sind ein vernünftiger Ausgangspunkt:

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"
  }'

Eine erfolgreiche 200-Antwort gibt nur Folgendes zurück:

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

Speichern Sie die task_id. Zu diesem Zeitpunkt wird nichts anderes zurückgegeben – die Videogenerierung läuft asynchron.

Schritt 4: Senden Sie Ihre erste I2V-Anfrage

I2V nimmt ein Startbild und animiert es gemäß Ihrem Prompt. Das Feld image_file erwartet einen Base64-kodierten String des Quellbilds:

# Kodieren Sie Ihr Bild zuerst
IMAGE_B64=$(base64 -w 0 /pfad/zu/ihrem/bild.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\"
  }"

Die Antwort hat die gleiche Form wie bei T2V:

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

Wichtige Bildbeschränkungen, die Sie vor dem Senden überprüfen sollten:

• Format: nur jpg, jpeg oder png
• Dateigröße: max. 10 MB (vor dem Kodieren prüfen – Base64 vergrößert die Größe um ~33 %)
• Mindestabmessungen: 300×300 Pixel
• Seitenverhältnis: zwischen 1:2,5 und 2,5:1 (Hoch- bis Querformatextreme)

Schritt 5: Ergebnisse abrufen

Fragen Sie den Task-Ergebnisendpunkt mit der task_id ab, die vom Übermittlungsschritt zurückgegeben wurde:

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

Das Feld task.status durchläuft diese Zustände:

Status	Bedeutung
TASK_STATUS_QUEUED	Task wartet in der Warteschlange
TASK_STATUS_PROCESSING	Generierung läuft
TASK_STATUS_SUCCEED	Video ist bereit; URL befindet sich in der Antwort
TASK_STATUS_FAILED	Generierung fehlgeschlagen; prüfen Sie task.reason

Rufen Sie alle 5–10 Sekunden ab. Wenn TASK_STATUS_SUCCEED erscheint, befindet sich die Video-URL im Antwortkörper. Das Feld task.eta liefert eine geschätzte Fertigstellungszeit in Sekunden, die Sie zur Planung Ihres ersten Abrufs verwenden können.

Schritt 6: Preise und Grenzen prüfen

Der veröffentlichte Preis von Novita AI für PixVerse V4.5 beträgt 0,70 $ pro 5-Sekunden-Clip (Stand Juli 2026, bestätigt von den Novita AI PixVerse Produktseiten). Überprüfen Sie den aktuellen Satz auf der Novita AI Preisseite, bevor Sie Kostenschätzungen erstellen.

fast_mode: true generiert Videos schneller und zu geringeren Kosten, aber die Auflösung ist auf 720p begrenzt. Es ist nützlich für Prototyping oder Batch-Vorschau-Generierung, bei denen die Qualität zweitrangig ist.

Die Ratenlimits skalieren je nach Kontostufe. Überprüfen Sie die Novita AI Ratenlimit-Dokumentation für aktuelle Stufenschwellen.

Wichtige Parameter

T2V-Parameter

Parameter	Typ	Standard	Hinweise
prompt	string	—	Erforderlich. Maximal 2048 Zeichen.
aspect_ratio	string	16:9	16:9, 4:3, 1:1, 3:4, 9:16
resolution	string	540p	360p, 540p, 720p, 1080p. 1080p erfordert fast_mode: false.
negative_prompt	string	—	Maximal 2048 Zeichen. Beschreiben Sie, was vermieden werden soll.
fast_mode	boolean	false	Schneller und günstiger; begrenzt auf 720p.
style	string	—	anime, 3d_animation, clay, comic, cyberpunk. Als nur für v3.5 gekennzeichnet – vor dem Produktiveinsatz testen.
seed	integer	—	Für Reproduzierbarkeit festlegen; Ausgaben können nach Modellaktualisierungen dennoch variieren.

I2V-Parameter

Parameter	Typ	Standard	Hinweise
prompt	string	—	Erforderlich. Maximal 2048 Zeichen.
image_file	string	—	Erforderlich. Base64-kodiertes jpg/jpeg/png. Max. 10 MB, min. 300×300 Pixel, Seitenverhältnis 1:2,5 bis 2,5:1.
resolution	string	540p	Gleiche Optionen wie bei T2V.
negative_prompt	string	—	Maximal 2048 Zeichen.
fast_mode	boolean	false	Gleich wie bei T2V.
style	string	—	Gleich wie bei T2V.
seed	integer	—	Gleich wie bei T2V.

Hinweis: I2V akzeptiert keinen aspect_ratio-Parameter – das Ausgabe-Seitenverhältnis wird vom eingegebenen Bild abgeleitet.

Python-Beispiel – Vollständiger asynchroner Workflow

Dieses Beispiel deckt sowohl die T2V- als auch die I2V-Übermittlung sowie die Abrufschleife in einem Skript ab:

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-Beispiele

T2V mit 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 mit Seed für Reproduzierbarkeit:

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
  }'

Ergebnis abrufen:

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

Fehlerbehebung

400 Bad Request bei I2V-Übermittlung

Überprüfen Sie zuerst die Bildbeschränkungen: Format muss jpg/jpeg/png sein, Größe muss unter 10 MB vor der Base64-Kodierung liegen (die kodierte Nutzlast wird ~33 % größer sein), mindestens 300×300 Pixel und Seitenverhältnis zwischen 1:2,5 und 2,5:1. Querformatextreme (sehr breite oder sehr hohe Bilder) werden abgelehnt.

Task bleibt lange in TASK_STATUS_QUEUED

Dies ist bei hoher Plattformlast normal. Das Feld task.eta gibt eine Schätzung; fragen Sie entsprechend ab, anstatt den Endpunkt zu überlasten. Wenn ein Task nach 10 Minuten keine Fortschritte gemacht hat, überprüfen Sie die Novita AI Statusseite oder wiederholen Sie die Übermittlung.

TASK_STATUS_FAILED ohne nützlichen Grund

Wiederholen Sie es mit einem kürzeren, einfacheren Prompt. Prompts mit mehrdeutigen Bewegungsanweisungen, widersprüchlichen Szenenbeschreibungen oder Charakteren, die unmögliche Physik ausführen, schlagen tendenziell fehl. Negative Prompts können auch mit dem Hauptprompt in Konflikt geraten, wenn sie zu weit gefasst sind.

1080p im Fast Mode nicht verfügbar

fast_mode: true begrenzt die Auflösung auf 720p. Wenn Sie 1080p benötigen, entfernen Sie fast_mode oder setzen Sie es auf false.

style-Parameter zeigt keine sichtbare Wirkung

Der style-Parameter ist als nur für v3.5 dokumentiert. Bei V4.5-Anfragen wird er möglicherweise stillschweigend ignoriert oder liefert inkonsistente Ergebnisse. Verlassen Sie sich nicht darauf, ohne Ihren spezifischen Anwendungsfall zu testen.

FAQ

Was ist der Unterschied zwischen T2V und I2V für PixVerse V4.5?

T2V generiert einen Videoclip vollständig aus einem Text-Prompt – es ist keine Bildeingabe erforderlich. I2V nimmt ein Startbild und animiert es gemäß dem Text-Prompt weiter, wobei das Bild als erster Frame verwendet wird. Verwenden Sie T2V für vollständig generierte Szenen; verwenden Sie I2V, wenn Sie einen bestimmten visuellen Ausgangspunkt haben, den Sie animieren möchten.

Welche Videolängen produziert PixVerse V4.5?

Clips sind 5 Sekunden bei 1080p und bis zu 8 Sekunden bei Auflösungen von 720p und darunter. Es gibt keinen duration-Parameter in der API – die Cliplänge wird durch die von Ihnen gewählte Auflösung bestimmt.

Leitet der I2V-Endpunkt das Seitenverhältnis aus dem Bild ab?

Ja. I2V hat keinen aspect_ratio-Parameter. Das Ausgabe-Seitenverhältnis entspricht dem eingegebenen Bild. Stellen Sie sicher, dass Ihr Bild vor dem Senden auf das beabsichtigte Ausgabe-Seitenverhältnis zugeschnitten ist.

Kann ich T2V- und I2V-Anfragen parallel senden?

Ja. Jede Anfrage gibt ihre eigene unabhängige task_id zurück. Sie können mehrere Anfragen gleichzeitig senden und parallel abrufen – Sie müssen nicht warten, bis eine abgeschlossen ist, bevor Sie die nächste senden.

Wie erhalte ich konsistente Ausgaben über mehrere Läufe hinweg?

Setzen Sie den seed-Parameter auf denselben Integer. Beachten Sie, dass die Reproduzierbarkeit basierend auf dem Seed nicht über Modellversionsaktualisierungen hinweg garantiert ist – speichern Sie die Video-URL und die Generierungsparameter zusammen, wenn Sie Ergebnisse später prüfen müssen.

Ist fast_mode für den Produktiveinsatz geeignet?

Das hängt von Ihrer Qualitätsanforderung ab. fast_mode: true generiert Videos schneller und kostet weniger, aber die Auflösung ist auf 720p begrenzt und die Qualität ist geringer als im Standardmodus. Es ist gut geeignet für Vorschaugenerierung, Batch-Auswertung und Prototyping; verwenden Sie den Standardmodus, wenn die Ausgabequalität der entscheidende Faktor ist.

Empfohlene Artikel

• PixVerse V4.5 T2V on Novita AI: The Cheapest Way to Build Cinematic AI Videos
• PixVerse V4.5 I2V on Novita AI: Fast, Flexible, and Cost-Effective AI Video
• Kling 3.0 Now on Novita AI: Cinematic AI Video Generation at Scale