Can the Vidu Q3 API generate dialogue, music, and video together?

Yes. Vidu Q3 natively generates video, dialogue, narration, sound effects, and background music in a synchronized output, eliminating the need for separate audio production.

What is the maximum video length supported by Vidu Q3 API?

Vidu Q3 supports video durations from 1 to 16 seconds per generation while maintaining audio-video synchronization throughout the clip.

When should I choose Vidu Q3 instead of Vidu Q3 Turbo?

Choose Vidu Q3 when output quality, narrative consistency, and cinematic storytelling are more important than generation speed. Q3 Turbo is optimized for faster iteration.

Does the Vidu Q3 API support image-to-video generation?

Yes. Vidu Q3 supports image-to-video workflows that animate still images into motion sequences while preserving visual identity and scene consistency.

Can Vidu Q3 create multi-character conversations with synchronized speech?

Yes. One of Vidu Q3's key capabilities is support for multi-speaker dialogue generation with synchronized audio and visual output.

What resolutions are available in the Vidu Q3 API?

The model supports 540p, 720p, and 1080p video generation at 24 FPS.

Is Vidu Q3 suitable for AI short films and narrative advertising?

Yes. Vidu Q3 was specifically designed for story-driven content such as short dramas, cinematic scenes, narrative advertisements, and comic-style productions.

What are the main limitations of the Vidu Q3 API?

A single generation is limited to 16 seconds, so longer productions require multiple clips and post-production editing to create extended narratives.

API Vidu Q3 Acessível | image-to-video

Especificações técnicas do Vidu Q3

Item	Vidu Q3 (viduq3-pro)
Model ID	viduq3-pro
Provider	Vidu
Model Family	Série Vidu Q3
Model Type	Geração de vídeo por IA
Input Types	Texto, Imagem, Imagem inicial + Imagem final
Output Type	Vídeo com áudio nativo sincronizado
Resolution	540p, 720p, 1080p
Duration	1–16 segundos
Frame Rate	24 FPS
Audio Generation	Geração nativa de áudio e vídeo
Text-to-Video	Suportado
Image-to-Video	Suportado
Start-End-to-Video	Suportado
Intelligent Shot Switching	Alternância inteligente de tomadas
Primary Focus	Narrativas e criação de vídeos cinematográficos

O que é o Vidu Q3?

O Vidu Q3 é o modelo de vídeo carro-chefe de terceira geração da Vidu, desenvolvido especificamente para geração de vídeos orientados por história. Ao contrário dos sistemas tradicionais de vídeo por IA que geram primeiro os visuais e depois o áudio, o Vidu Q3 cria diálogo, narração, efeitos sonoros, música e vídeo simultaneamente, possibilitando storytelling sincronizado diretamente em um único fluxo de geração. O modelo é projetado para dramas curtos, sequências cinematográficas, conteúdo publicitário e narrativas centradas em personagens.

Principais recursos do Vidu Q3

Sincronização nativa de áudio e vídeo: Gera diálogo, narração, efeitos sonoros e música diretamente junto ao vídeo.
Geração contínua de 16 segundos: Produz clipes narrativos completos em uma única execução de geração.
Controle de câmera com precisão no nível de quadro: Suporta controle detalhado de movimento de câmera, ritmo e composição de cena.
Suporte a diálogos com múltiplos locutores: Projetado para conversas e interações entre personagens.
Geração multilíngue: Suporta geração de conteúdo em inglês, japonês e chinês.
Otimização para storytelling cinematográfico: Ajustado especificamente para drama, conteúdo em estilo de filme, quadrinhos e publicidade narrativa.

Desempenho de benchmark do Vidu Q3

Diferentemente de modelos de linguagem, o Vidu Q3 não publica pontuações padronizadas de benchmark como MMLU ou SWE-Bench. Os indicadores de desempenho divulgados publicamente incluem:

Métrica	Informação pública
Duração máxima	16 segundos
Resolução máxima	1080p
Geração de áudio nativa	Sim
Diálogo com múltiplos locutores	Sim
Suporte multilíngue	inglês, japonês e chinês
Controle de câmera no nível de quadro	Sim

Pontuação no Artificial Analysis de 1241 e classificação entre os principais sistemas globais de geração de vídeo, embora a validação de benchmark independente ainda seja limitada.

Vidu Q3 vs Vidu Q3 Turbo vs Kling 2.1

Recurso	Vidu Q3	Vidu Q3 Turbo	Kling 2.1
Posicionamento	Qualidade premium	Otimizado para velocidade	Geração de vídeo geral
Áudio nativo	Sim	Sim	Dependente do fluxo de trabalho
Duração máxima	16s	16s	Varia
Resolução	Até 1080p	Até 1080p	Até 1080p
Controle de câmera	Avançado	Avançado	Forte
Foco narrativo	Máximo	Moderado	Forte
Velocidade de geração	Padrão	Mais rápida	Competitiva

Limitações conhecidas

Clipes individuais continuam limitados a 16 segundos.
Produções de longa duração exigem a combinação de múltiplas gerações.
A transparência de benchmarks públicos permanece limitada em comparação com os principais provedores de LLM.
A qualidade da narrativa depende fortemente do design dos prompts e do planejamento das cenas.

Casos de uso representativos

Curtas-metragens com IA

Gere cenas cinematográficas com fala, som ambiente e música sincronizados.

Produção de dramas curtos

Crie conteúdo de drama serializado sem fluxos de trabalho separados de produção de áudio.

Publicidade e storytelling de marca

Produza comerciais narrativos com narração e design de som integrados.

Adaptação de quadrinhos e mangá

Transforme storyboards e ilustrações em clipes narrativos animados.

Criação de vídeos para redes sociais

Gere conteúdo para TikTok, Shorts e Reels com áudio sincronizado pronto para publicação.

Notas sobre a versão do modelo

O Vidu Q3 representa a versão premium da família Q3. Em comparação com o Vidu Q3 Turbo, o modelo Q3 padrão prioriza a qualidade de saída, a consistência narrativa e o storytelling cinematográfico, em vez da velocidade de geração. Ambos os modelos suportam saída nativa de áudio e vídeo e geração de vídeos de até 16 segundos.

Como acessar e implantar a API viduq3 no CometAPI

Crie sua conta no CometAPI ou faça login em uma conta existente para acessar a API assim que estiver disponível (HappyHorse-1.0 API). Após o lançamento, você poderá obter uma chave de API HappyHorse-1.0 na plataforma e ficar pronto para testes ou integração.

Etapa 2: Teste gratuitamente a API viduq3 no playground

Antes da implantação, você pode experimentar a API viduq3 diretamente no playground do CometAPI. Isso oferece uma maneira simples de explorar a qualidade de saída, testar prompts ou entradas de imagem e obter uma compreensão mais clara do desempenho da HappyHorse-1.0 API antes de usá-la em produção.

Etapa 3: Implemente a API viduq3 em produção

Após os testes, a próxima etapa é implantar a API viduq3 em seu próprio aplicativo, produto ou ambiente interno. Isso permite usar a API viduq3 em cenários reais de geração de vídeo, nos quais acesso estável e integração prática são cruciais.

Preços para Vidu Q3

Explore preços competitivos para Vidu Q3, projetado para atender diversos orçamentos e necessidades de uso. Nossos planos flexíveis garantem que você pague apenas pelo que usar, facilitando o dimensionamento conforme suas necessidades crescem. Descubra como Vidu Q3 pode aprimorar seus projetos mantendo os custos gerenciáveis.

Vidu Video Generation Pricing

Pricing (Per Second)

Model	360p	540p	720p	1080p
`viduq3`	$0.056	$0.056	$0.1232	$0.1232
`viduq3-turbo`	$0.028	$0.028	$0.0616	$0.0616

💡 Billed per second. Total cost = price per second × video duration (seconds).

Código de exemplo e API para Vidu Q3

Acesse código de exemplo abrangente e recursos de API para Vidu Q3 para otimizar seu processo de integração. Nossa documentação detalhada fornece orientação passo a passo, ajudando você a aproveitar todo o potencial do Vidu Q3 em seus projetos.

Python
JavaScript
Curl

# Create a video with viduq3 using raw HTTP requests
import os
import time
import requests

api_key = os.environ.get("COMETAPI_KEY")
base_url = "https://api.cometapi.com/v1"
headers = {"Authorization": f"Bearer {api_key}"}

# Step 1: Submit the video generation request
print("Submitting video generation request...")
response = requests.post(
    f"{base_url}/videos",
    headers=headers,
    files={
        "model": (None, "viduq3"),
        "prompt": (None, "Ultra-realistic cinematic shot of an astronaut walking slowly through soft fog, volumetric light in light blue and pale amber tones, shallow depth of field, 35mm film texture, graceful camera movement."),
        "seconds": (None, "1"),
        "size": (None, "960x528"),
    },
)

result = response.json()
print(f"Response: {result}")

video_id = result.get("id") or result.get("task_id")
print(f"Video ID: {video_id}")

# Step 2: Poll for progress until 100%
print("
Checking video generation progress...")
while True:
    try:
        status_response = requests.get(f"{base_url}/videos/{video_id}", headers=headers)
        status_result = status_response.json()

        data = status_result.get("data") or status_result
        progress = data.get("progress", "0%")
        status = data.get("status", "unknown")

        print(f"Progress: {progress}, Status: {status}")

        if status in ["FAILURE", "failed", "error"]:
            print("Video generation failed!")
            print(status_result)
            exit(1)

        if progress == "100%" or progress == 100 or status in ["completed", "success"]:
            print("Video generation completed!")
            break
    except Exception as e:
        print(f"Temporary error: {e}, retrying...")

    time.sleep(10)

# Step 3: Download the video to output directory
print(f"
Downloading video to ./output/{video_id}.mp4...")
os.makedirs("./output", exist_ok=True)

video_response = requests.get(f"{base_url}/videos/{video_id}/content", headers=headers)

output_path = f"./output/{video_id}.mp4"
with open(output_path, "wb") as f:
    f.write(video_response.content)

if os.path.exists(output_path):
    file_size = os.path.getsize(output_path)
    print(f"Video saved to {output_path}")
    print(f"File size: {file_size} bytes")
else:
    print("Failed to download video")
    exit(1)

Python Code Example

# Create a video with viduq3 using raw HTTP requests
import os
import time
import requests

api_key = os.environ.get("COMETAPI_KEY")
base_url = "https://api.cometapi.com/v1"
headers = {"Authorization": f"Bearer {api_key}"}

# Step 1: Submit the video generation request
print("Submitting video generation request...")
response = requests.post(
    f"{base_url}/videos",
    headers=headers,
    files={
        "model": (None, "viduq3"),
        "prompt": (None, "Ultra-realistic cinematic shot of an astronaut walking slowly through soft fog, volumetric light in light blue and pale amber tones, shallow depth of field, 35mm film texture, graceful camera movement."),
        "seconds": (None, "1"),
        "size": (None, "960x528"),
    },
)

result = response.json()
print(f"Response: {result}")

video_id = result.get("id") or result.get("task_id")
print(f"Video ID: {video_id}")

# Step 2: Poll for progress until 100%
print("\nChecking video generation progress...")
while True:
    try:
        status_response = requests.get(f"{base_url}/videos/{video_id}", headers=headers)
        status_result = status_response.json()

        data = status_result.get("data") or status_result
        progress = data.get("progress", "0%")
        status = data.get("status", "unknown")

        print(f"Progress: {progress}, Status: {status}")

        if status in ["FAILURE", "failed", "error"]:
            print("Video generation failed!")
            print(status_result)
            exit(1)

        if progress == "100%" or progress == 100 or status in ["completed", "success"]:
            print("Video generation completed!")
            break
    except Exception as e:
        print(f"Temporary error: {e}, retrying...")

    time.sleep(10)

# Step 3: Download the video to output directory
print(f"\nDownloading video to ./output/{video_id}.mp4...")
os.makedirs("./output", exist_ok=True)

video_response = requests.get(f"{base_url}/videos/{video_id}/content", headers=headers)

output_path = f"./output/{video_id}.mp4"
with open(output_path, "wb") as f:
    f.write(video_response.content)

if os.path.exists(output_path):
    file_size = os.path.getsize(output_path)
    print(f"Video saved to {output_path}")
    print(f"File size: {file_size} bytes")
else:
    print("Failed to download video")
    exit(1)

JavaScript Code Example

// Create a video with viduq3 using raw HTTP requests
import fs from "fs";
import path from "path";

const apiKey = process.env.COMETAPI_KEY;
const baseUrl = "https://api.cometapi.com/v1";
const headers = { Authorization: `Bearer ${apiKey}` };

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

// Step 1: Submit the video generation request
console.log("Submitting video generation request...");
const formData = new FormData();
formData.append("model", "viduq3");
formData.append("prompt", "Ultra-realistic cinematic shot of an astronaut walking slowly through soft fog, volumetric light in light blue and pale amber tones, shallow depth of field, 35mm film texture, graceful camera movement.");
formData.append("seconds", "1");
formData.append("size", "960x528");

const submitResponse = await fetch(`${baseUrl}/videos`, {
  method: "POST",
  headers,
  body: formData,
});

const result = await submitResponse.json();
console.log("Response:", JSON.stringify(result, null, 2));

const videoId = result.id || result.task_id;
console.log("Video ID:", videoId);

// Step 2: Poll for progress until 100%
console.log("\nChecking video generation progress...");
while (true) {
  try {
    const statusResponse = await fetch(`${baseUrl}/videos/${videoId}`, { headers });
    const statusResult = await statusResponse.json();
    const data = statusResult.data || statusResult;
    const progress = data.progress || "0%";
    const status = data.status || "unknown";

    console.log(`Progress: ${progress}, Status: ${status}`);

    if (status === "FAILURE" || status === "failed" || status === "error") {
      console.log("Video generation failed!");
      console.log(JSON.stringify(statusResult, null, 2));
      process.exit(1);
    }

    if (progress === "100%" || progress === 100 || status === "completed" || status === "success") {
      console.log("Video generation completed!");
      break;
    }
  } catch (e) {
    console.log(`Temporary error: ${e.message}, retrying...`);
  }

  await sleep(10000);
}

// Step 3: Download the video to output directory
console.log(`\nDownloading video to ./output/${videoId}.mp4...`);
fs.mkdirSync("./output", { recursive: true });

const videoResponse = await fetch(`${baseUrl}/videos/${videoId}/content`, { headers });
const outputPath = path.join("./output", `${videoId}.mp4`);
fs.writeFileSync(outputPath, Buffer.from(await videoResponse.arrayBuffer()));

if (fs.existsSync(outputPath)) {
  const stats = fs.statSync(outputPath);
  console.log(`Video saved to ${outputPath}`);
  console.log(`File size: ${stats.size} bytes`);
} else {
  console.log("Failed to download video");
  process.exit(1);
}

Curl Code Example

# Create a video with viduq3
# Step 1: Submit the video generation request
echo "Submitting video generation request..."
response=$(curl -s https://api.cometapi.com/v1/videos \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -F "model=viduq3" \
  -F "prompt=Ultra-realistic cinematic shot of an astronaut walking slowly through soft fog, volumetric light in light blue and pale amber tones, shallow depth of field, 35mm film texture, graceful camera movement." \
  -F "seconds=1" \
  -F "size=960x528")

echo "Response: $response"

# Extract video_id from response (handle JSON with spaces like "id": "xxx")
video_id=$(echo "$response" | tr -d '\n' | sed 's/.*"id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/')
echo "Video ID: $video_id"

# Step 2: Poll for progress until 100%
echo ""
echo "Checking video generation progress..."
while true; do
  status_response=$(curl -s "https://api.cometapi.com/v1/videos/$video_id" \
    -H "Authorization: Bearer $COMETAPI_KEY")
  
  progress=$(echo "$status_response" | grep -o '"progress"[[:space:]]*:[[:space:]]*"\?[^",}]*"\?' | head -1 | sed 's/.*:[[:space:]]*"\?//;s/"$//')
  status=$(echo "$status_response" | grep -o '"status"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed 's/.*"status"[[:space:]]*:[[:space:]]*"//;s/"$//')
  
  echo "Progress: $progress, Status: $status"
  
  if [ "$status" = "FAILURE" ] || [ "$status" = "failed" ] || [ "$status" = "error" ]; then
    echo "Video generation failed!"
    exit 1
  fi
  
  if [ "$progress" = "100%" ] || [ "$progress" = "100" ] || [ "$status" = "completed" ] || [ "$status" = "success" ]; then
    echo "Video generation completed!"
    break
  fi
  
  sleep 10
done

# Step 3: Download the video to output directory
echo ""
echo "Downloading video to ./output/$video_id.mp4..."
mkdir -p ./output
curl -s "https://api.cometapi.com/v1/videos/$video_id/content" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -o "./output/$video_id.mp4"

if [ -f "./output/$video_id.mp4" ]; then
  echo "Video saved to ./output/$video_id.mp4"
  ls -la "./output/$video_id.mp4"
else
  echo "Failed to download video"
  exit 1
fi

Versões do Vidu Q3

O motivo pelo qual Vidu Q3 possui múltiplas versões instantâneas pode incluir fatores como variações na saída após atualizações que exigem versões antigas para consistência, fornecendo aos desenvolvedores um período de transição para adaptação e migração, e diferentes versões correspondentes a endpoints globais ou regionais para otimizar a experiência do usuário. Para diferenças detalhadas entre versões, consulte a documentação oficial.

version
viduq3-turbo
viduq3

Vidu Q3