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

PixVerse V4.5 Guia Rápido para Geração de Texto para Vídeo e Imagem para Vídeo

Por / / Video, API / 8 minutos de leitura
PixVerse V4.5 Guia Rápido para Geração de Texto para Vídeo e Imagem para Vídeo
Índice
  1. Quando Usar Este Guia Rápido
  2. Passo 1: Obtenha sua Chave de API da Novita
  3. Passo 2: Confirme os Endpoints
  4. Passo 3: Envie Sua Primeira Requisição T2V
  5. Passo 4: Envie Sua Primeira Requisição I2V
  6. Passo 5: Consulte os Resultados
  7. Passo 6: Verifique Preços e Limites
  8. Parâmetros Principais
  9. Exemplo em Python — Fluxo de Trabalho Assíncrono Completo
  10. Exemplos em cURL
  11. Solução de Problemas
  12. Perguntas Frequentes (FAQ)
  13. Artigos Recomendados

O PixVerse V4.5 está disponível na Novita AI através de dois endpoints assíncronos: POST https://api.novita.ai/v3/async/pixverse-v4.5-t2v para texto para vídeo (T2V) e POST https://api.novita.ai/v3/async/pixverse-v4.5-i2v para imagem para vídeo (I2V). Ambos seguem o mesmo padrão assíncrono de duas etapas — envie uma requisição de geração, receba um task_id, então consulte GET /v3/async/task-result até que o status seja TASK_STATUS_SUCCEED e a URL do vídeo esteja disponível. Este guia leva você do zero até uma URL de vídeo funcional para cada modo.

Quando Usar Este Guia Rápido

Use este guia quando precisar de uma requisição verificada e funcional antes de escrever lógica de produção em torno do PixVerse V4.5.

T2V é o caminho certo quando sua entrada é inteiramente texto — uma descrição de cena, uma legenda de storyboard ou um prompt de produto. I2V é para casos em que você tem uma imagem de referência e deseja que o PixVerse a anime a partir desse quadro.

Vale a pena saber antes de começar:

  • Os clipes duram no máximo 5 segundos em 1080p, ou 8 segundos em 720p e abaixo.
  • fast_mode: true acelera a geração e reduz o custo, mas limita a resolução a 720p.
  • O parâmetro predefinido style (anime, 3d_animation, clay, comic, cyberpunk) é documentado como exclusivo da v3.5 — teste-o contra o V4.5 antes de confiar nele em produção.
  • As entradas de imagem I2V devem ser jpg, jpeg ou png; no máximo 10MB; mínimo 300×300px; e uma proporção de aspecto entre 1:2.5 e 2.5:1.

Este guia não cobre a interface web do PixVerse, auto-hospedagem ou fine-tuning. Ele cobre apenas o caminho da API hospedada pela Novita AI.

Passo 1: Obtenha sua Chave de API da Novita

Crie uma conta na Novita AI e navegue até Gerenciamento de chaves de API. Gere uma chave e exporte-a para seu ambiente:

export NOVITA_API_KEY="your_api_key_here"

Mantenha a chave fora do controle de versão, bundles do lado do cliente e camadas de imagem Docker.

Passo 2: Confirme os Endpoints

T2V I2V
Endpoint de submissã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 resultado GET https://api.novita.ai/v3/async/task-result?task_id=<id> GET https://api.novita.ai/v3/async/task-result?task_id=<id>
Referência da API Documentação T2V Documentação I2V

O endpoint de resultado é compartilhado entre todas as APIs assíncronas da Novita AI. Depois de entender o loop de consulta, ele funciona da mesma forma para todos os modelos.

Passo 3: Envie Sua Primeira Requisição T2V

Envie uma geração com um prompt e sua proporção de aspecto preferida. Os padrões (aspect_ratio: "16:9", resolution: "540p", fast_mode: false) são um ponto de partida razoável:

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

Uma resposta 200 bem-sucedida retorna apenas:

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

Salve o task_id. Nada mais é retornado neste estágio — a geração do vídeo é executada de forma assíncrona.

Passo 4: Envie Sua Primeira Requisição I2V

I2V recebe uma imagem inicial e a anima de acordo com seu prompt. O campo image_file espera uma string codificada em base64 da imagem de origem:

# 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\"
  }"

A resposta tem a mesma forma que T2V:

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

Restrições importantes da imagem a verificar antes de enviar:

  • Formato: apenas jpg, jpeg ou png
  • Tamanho do arquivo: máximo 10MB (verifique antes de codificar — base64 expande o tamanho em ~33%)
  • Dimensões mínimas: 300×300px
  • Proporção de aspecto: entre 1:2.5 e 2.5:1 (extremos de retrato a paisagem)

Passo 5: Consulte os Resultados

Consulte o endpoint de resultado da tarefa com o task_id retornado da etapa de submissão:

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

O campo task.status percorre estes estados:

Status Significado
TASK_STATUS_QUEUED A tarefa está aguardando na fila
TASK_STATUS_PROCESSING A geração está em execução
TASK_STATUS_SUCCEED O vídeo está pronto; a URL está na resposta
TASK_STATUS_FAILED A geração falhou; verifique task.reason

Consulte a cada 5–10 segundos. Quando TASK_STATUS_SUCCEED aparecer, a URL do vídeo estará no corpo da resposta. O campo task.eta fornece um tempo estimado de conclusão em segundos, que você pode usar para agendar sua primeira consulta.

Passo 6: Verifique Preços e Limites

O preço publicado da Novita AI para o PixVerse V4.5 é de $0,7 por clipe de 5 segundos (verificado nas páginas de produtos PixVerse da Novita AI em julho de 2026). Verifique a taxa atual na página de preços da Novita AI antes de fazer qualquer estimativa de custo.

fast_mode: true gera vídeos mais rápido e com menor custo, mas a resolução é limitada a 720p. É útil para prototipagem ou geração de pré-visualização em lote onde a qualidade é secundária.

Os limites de taxa escalam por nível de conta. Verifique a documentação de limites de taxa da Novita AI para obter os limites atuais do nível.

Parâmetros Principais

Parâmetros T2V

Parâmetro Tipo Padrão Notas
prompt string — Obrigatório. 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 requer fast_mode: false.
negative_prompt string — Máximo 2048 caracteres. Descreva o que evitar.
fast_mode boolean false Mais rápido e mais barato; limita a 720p.
style string — anime, 3d_animation, clay, comic, cyberpunk. Rotulado como exclusivo da v3.5 — teste antes do uso em produção.
seed integer — Defina para reprodutibilidade; as saídas ainda podem variar após atualizações do modelo.

Parâmetros I2V

Parâmetro Tipo Padrão Notas
prompt string — Obrigatório. Máximo 2048 caracteres.
image_file string — Obrigatório. jpg/jpeg/png codificado em base64. Máximo 10MB, mínimo 300×300px, proporção de aspecto 1:2.5 a 2.5:1.
resolution string 540p Mesmas opções que T2V.
negative_prompt string — Máximo 2048 caracteres.
fast_mode boolean false Mesmo que T2V.
style string — Mesmo que T2V.
seed integer — Mesmo que T2V.

Nota: I2V não aceita um parâmetro aspect_ratio — a proporção de aspecto da saída é derivada da imagem de entrada.

Exemplo em Python — Fluxo de Trabalho Assíncrono Completo

Este exemplo cobre tanto a submissão T2V quanto I2V, além do loop de consulta em um único 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)

Exemplos em cURL

T2V com 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 com seed para reprodutibilidade:

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"

Solução de Problemas

400 Bad Request na submissão I2V

Verifique primeiro as restrições da imagem: o formato deve ser jpg/jpeg/png, o tamanho deve ser inferior a 10MB antes da codificação base64 (o payload codificado será ~33% maior), mínimo 300×300px e proporção de aspecto entre 1:2.5 e 2.5:1. Extremos de paisagem (imagens muito largas ou muito altas) serão rejeitados.

Tarefa permanece em TASK_STATUS_QUEUED por muito tempo

Isso é normal sob alta carga da plataforma. O campo task.eta fornece uma estimativa; consulte de acordo, em vez de sobrecarregar o endpoint. Se uma tarefa não avançar após 10 minutos, verifique a página de status da Novita AI ou tente a submissão novamente.

TASK_STATUS_FAILED sem motivo útil

Tente novamente com um prompt mais curto e simples. Prompts com instruções de movimento ambíguas, descrições de cena contraditórias ou personagens realizando física impossível tendem a falhar. Prompts negativos também podem entrar em conflito com o prompt principal se forem muito amplos.

1080p não disponível no modo rápido

fast_mode: true limita a resolução a 720p. Se você precisar de 1080p, remova fast_mode ou defina-o como false.

O parâmetro style não tem efeito visível

O parâmetro style é documentado como exclusivo da v3.5. Em requisições V4.5, ele pode ser ignorado silenciosamente ou produzir resultados inconsistentes. Não confie nele sem testar seu caso de uso específico.

Perguntas Frequentes (FAQ)

Qual é a diferença entre T2V e I2V para o PixVerse V4.5?

T2V gera um clipe de vídeo inteiramente a partir de um prompt de texto — nenhuma entrada de imagem é necessária. I2V recebe uma imagem inicial e a anima de acordo com o prompt de texto, usando a imagem como o primeiro quadro. Use T2V para cenas totalmente geradas; use I2V quando você tiver um ponto de partida visual específico que deseja animar.

Quais durações de vídeo o PixVerse V4.5 produz?

Os clipes têm 5 segundos em 1080p e até 8 segundos em resoluções de 720p e abaixo. Não há parâmetro duration na API — a duração do clipe é determinada pela resolução que você seleciona.

O endpoint I2V infere a proporção de aspecto da imagem?

Sim. I2V não possui parâmetro aspect_ratio. A proporção de aspecto da saída corresponde à imagem de entrada. Certifique-se de que sua imagem seja cortada para a proporção de saída desejada antes de enviar.

Posso enviar requisições T2V e I2V em paralelo?

Sim. Cada requisição retorna seu próprio task_id independente. Você pode enviar várias requisições simultaneamente e consultá-las em paralelo — não há necessidade de esperar uma ser concluída antes de enviar a próxima.

Como obtenho saídas consistentes entre execuções?

Defina o parâmetro seed para o mesmo inteiro. Tenha em mente que a reprodutibilidade baseada em seed não é garantida em atualizações de versão do modelo — armazene a URL do vídeo e os parâmetros de geração juntos se precisar auditar resultados posteriormente.

O fast_mode é adequado para uso em produção?

Depende do seu padrão de qualidade. fast_mode: true gera vídeos mais rápido e custa menos, mas a resolução é limitada a 720p e a qualidade é inferior ao modo padrão. É adequado para geração de pré-visualização, avaliação em lote e prototipagem; use o modo padrão quando a qualidade da saída for o fator decisivo.

Artigos Recomendados

Posts relacionados