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

Inicio rápido de PixVerse V4.5 para generación de texto a video y de imagen a video

Por / / Video, API / 8 minutos de lectura
Inicio rápido de PixVerse V4.5 para generación de texto a video y de imagen a video
Tabla de contenido
  1. Cuándo usar este inicio rápido
  2. Paso 1: Obtén tu clave de API de Novita
  3. Paso 2: Confirma los endpoints
  4. Paso 3: Envía tu primera solicitud T2V
  5. Paso 4: Envía tu primera solicitud I2V
  6. Paso 5: Consulta los resultados
  7. Paso 6: Verifica precios y límites
  8. Parámetros clave
  9. Ejemplo en Python — Flujo de trabajo asíncrono completo
  10. Ejemplos con cURL
  11. Solución de problemas
  12. Preguntas frecuentes
  13. Artículos recomendados

PixVerse V4.5 está disponible en Novita AI a través de dos endpoints asíncronos: POST https://api.novita.ai/v3/async/pixverse-v4.5-t2v para texto a video (T2V) y POST https://api.novita.ai/v3/async/pixverse-v4.5-i2v para imagen a video (I2V). Ambos siguen el mismo patrón asíncrono de dos pasos: envía una solicitud de generación, recibe un task_id, luego consulta GET /v3/async/task-result hasta que el estado sea TASK_STATUS_SUCCEED y la URL del video esté disponible. Esta guía te lleva de cero a tener una URL de video funcional para cada modo.

Cuándo usar este inicio rápido

Usa esta guía cuando necesites una solicitud de trabajo verificada antes de escribir la lógica de producción para PixVerse V4.5.

T2V es el camino correcto cuando tu entrada es completamente textual: una descripción de escena, un título de storyboard o un prompt de producto. I2V es para casos donde tienes una imagen de referencia y deseas que PixVerse la anime a partir de ese fotograma.

Vale la pena saber antes de empezar:

  • Los clips duran como máximo 5 segundos en 1080p, u 8 segundos en 720p y resoluciones inferiores.
  • fast_mode: true acelera la generación y reduce el costo, pero limita la resolución a 720p.
  • El parámetro de preset style (anime, 3d_animation, clay, comic, cyberpunk) está documentado solo para v3.5 — pruébalo con V4.5 antes de confiar en él en producción.
  • Las imágenes de entrada para I2V deben ser jpg, jpeg o png; máximo 10 MB; mínimo 300×300 px; y una relación de aspecto entre 1:2.5 y 2.5:1.

Esta guía no cubre la interfaz web de PixVerse, el autohospedaje ni el ajuste fino. Cubre solo la ruta de API alojada en Novita AI.

Paso 1: Obtén tu clave de API de Novita

Crea una cuenta en Novita AI y navega a Gestión de claves de API. Genera una clave y expórtala a tu entorno:

export NOVITA_API_KEY="tu_api_key_aqui"

Mantén la clave fuera del control de versiones, los bundles del lado del cliente y las capas de imagen de Docker.

Paso 2: Confirma los endpoints

T2V I2V
Endpoint de envío POST https://api.novita.ai/v3/async/pixverse-v4.5-t2v POST https://api.novita.ai/v3/async/pixverse-v4.5-i2v
Endpoint de resultados GET https://api.novita.ai/v3/async/task-result?task_id=<id> GET https://api.novita.ai/v3/async/task-result?task_id=<id>
Referencia de API Documentación T2V Documentación I2V

El endpoint de resultados es compartido por todas las API asíncronas de Novita AI. Una vez que entiendas el bucle de consulta, funciona igual para cada modelo.

Paso 3: Envía tu primera solicitud T2V

Envía una generación con un prompt y tu relación de aspecto preferida. Los valores predeterminados (aspect_ratio: "16:9", resolution: "540p", fast_mode: false) son un punto de partida razonable:

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

Una respuesta exitosa 200 devuelve solo:

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

Guarda el task_id. No se devuelve nada más en esta etapa: la generación del video se ejecuta de forma asíncrona.

Paso 4: Envía tu primera solicitud I2V

I2V toma una imagen de inicio y la anima según tu prompt. El campo image_file espera una cadena codificada en base64 de la imagen fuente:

# Codifica tu imagen primero
IMAGE_B64=$(base64 -w 0 /ruta/a/tu/imagen.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\"
  }"

La respuesta tiene la misma forma que T2V:

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

Restricciones clave de imagen a verificar antes de enviar:

  • Formato: solo jpg, jpeg o png
  • Tamaño de archivo: máximo 10 MB (verifica antes de codificar — base64 expande el tamaño aproximadamente un 33%)
  • Dimensiones mínimas: 300×300 px
  • Relación de aspecto: entre 1:2.5 y 2.5:1 (extremos vertical a horizontal)

Paso 5: Consulta los resultados

Consulta el endpoint de resultado de tarea con el task_id devuelto en el paso de envío:

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

El campo task.status pasa por estos estados:

Estado Significado
TASK_STATUS_QUEUED La tarea está esperando en la cola
TASK_STATUS_PROCESSING La generación se está ejecutando
TASK_STATUS_SUCCEED El video está listo; la URL está en la respuesta
TASK_STATUS_FAILED La generación falló; revisa task.reason

Consulta cada 5–10 segundos. Cuando aparezca TASK_STATUS_SUCCEED, la URL del video estará en el cuerpo de la respuesta. El campo task.eta proporciona un tiempo estimado de finalización en segundos, que puedes usar para programar tu primera consulta.

Paso 6: Verifica precios y límites

El precio publicado de Novita AI para PixVerse V4.5 es de $0.7 por clip de 5 segundos (verificado desde las páginas de producto de PixVerse de Novita AI a julio de 2026). Verifica la tarifa actual en la página de precios de Novita AI antes de hacer cualquier estimación de costos.

fast_mode: true genera videos más rápido y a menor costo, pero la resolución está limitada a 720p. Es útil para prototipado o generación de vistas previas por lotes donde la calidad es secundaria.

Los límites de velocidad escalan según el nivel de la cuenta. Consulta la documentación de límites de velocidad de Novita AI para conocer los umbrales actuales por nivel.

Parámetros clave

Parámetros T2V

Parámetro Tipo Predeterminado Notas
prompt string — Obligatorio. Máximo 2048 caracteres.
aspect_ratio string 16:9 16:9, 4:3, 1:1, 3:4, 9:16
resolution string 540p 360p, 540p, 720p, 1080p. 1080p requiere fast_mode: false.
negative_prompt string — Máximo 2048 caracteres. Describe lo que se debe evitar.
fast_mode boolean false Más rápido y más barato; limita a 720p.
style string — anime, 3d_animation, clay, comic, cyberpunk. Etiquetado solo para v3.5 — prueba antes de usar en producción.
seed integer — Se establece para reproducibilidad; los resultados pueden variar después de actualizaciones del modelo.

Parámetros I2V

Parámetro Tipo Predeterminado Notas
prompt string — Obligatorio. Máximo 2048 caracteres.
image_file string — Obligatorio. Codificado en base64 jpg/jpeg/png. Máximo 10 MB, mínimo 300×300 px, relación de aspecto 1:2.5 a 2.5:1.
resolution string 540p Mismas opciones que T2V.
negative_prompt string — Máximo 2048 caracteres.
fast_mode boolean false Igual que T2V.
style string — Igual que T2V.
seed integer — Igual que T2V.

Nota: I2V no acepta un parámetro aspect_ratio — la relación de aspecto de salida se deriva de la imagen de entrada.

Ejemplo en Python — Flujo de trabajo asíncrono completo

Este ejemplo cubre tanto el envío T2V como I2V, además del bucle de consulta en un solo 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__":
    # Texto a 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)

    # Imagen a video — reemplaza con una ruta de imagen real
    # 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)

Ejemplos con cURL

T2V con modo rápido:

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 con semilla para reproducibilidad:

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

Consultar resultado:

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

Solución de problemas

Error 400 Bad Request en el envío I2V

Primero verifica las restricciones de la imagen: el formato debe ser jpg/jpeg/png, el tamaño debe ser inferior a 10 MB antes de la codificación base64 (el payload codificado será aproximadamente un 33% más grande), mínimo 300×300 px y relación de aspecto entre 1:2.5 y 2.5:1. Los extremos de paisaje (imágenes muy anchas o muy altas) serán rechazados.

La tarea permanece en TASK_STATUS_QUEUED durante mucho tiempo

Esto es normal bajo alta carga en la plataforma. El campo task.eta proporciona una estimación; consulta en consecuencia en lugar de golpear el endpoint repetidamente. Si una tarea no ha avanzado después de 10 minutos, revisa la página de estado de Novita AI o reintenta el envío.

TASK_STATUS_FAILED sin una razón útil

Reintenta con un prompt más corto y simple. Los prompts con instrucciones de movimiento ambiguas, descripciones de escena contradictorias o personajes realizando física imposible tienden a fallar. Los prompts negativos también pueden entrar en conflicto con el prompt principal si son demasiado amplios.

1080p no disponible en modo rápido

fast_mode: true limita la resolución a 720p. Si necesitas 1080p, elimina fast_mode o establécelo en false.

El parámetro style no tiene un efecto visible

El parámetro style está documentado solo para v3.5. En solicitudes V4.5 puede ignorarse silenciosamente o producir resultados inconsistentes. No confíes en él sin probar tu caso de uso específico.

Preguntas frecuentes

¿Cuál es la diferencia entre T2V e I2V para PixVerse V4.5?

T2V genera un clip de video completamente a partir de un prompt de texto — no se necesita ninguna imagen de entrada. I2V toma una imagen de inicio y la anima según el prompt de texto, utilizando la imagen como el primer fotograma. Usa T2V para escenas completamente generadas; usa I2V cuando tengas un punto de partida visual específico que quieras animar.

¿Qué duraciones de video produce PixVerse V4.5?

Los clips son de 5 segundos en 1080p y hasta 8 segundos en resoluciones de 720p e inferiores. No hay un parámetro duration en la API — la duración del clip está determinada por la resolución que selecciones.

¿El endpoint I2V infiere la relación de aspecto de la imagen?

Sí. I2V no tiene un parámetro aspect_ratio. La relación de aspecto de salida coincide con la de la imagen de entrada. Asegúrate de que tu imagen esté recortada a la relación de aspecto deseada antes de enviarla.

¿Puedo enviar solicitudes T2V e I2V en paralelo?

Sí. Cada solicitud devuelve su propio task_id independiente. Puedes enviar múltiples solicitudes concurrentemente y consultarlas en paralelo — no es necesario esperar a que una se complete antes de enviar la siguiente.

¿Cómo obtengo resultados consistentes entre ejecuciones?

Establece el parámetro seed al mismo entero. Ten en cuenta que la reproducibilidad basada en semillas no está garantizada entre actualizaciones de versión del modelo — almacena la URL del video y los parámetros de generación juntos si necesitas auditar los resultados más tarde.

¿Es fast_mode adecuado para uso en producción?

Depende de tu nivel de calidad. fast_mode: true genera videos más rápido y cuesta menos, pero la resolución está limitada a 720p y la calidad es inferior al modo estándar. Es muy adecuado para generación de vistas previas, evaluación por lotes y prototipado; usa el modo estándar cuando la calidad de salida sea el factor decisivo.

Artículos recomendados

Publicaciones relacionadas