Can the Vidu Q3 Turbo API generate video and audio at the same time?

Sim. O Vidu Q3 Turbo oferece geração nativa de áudio e vídeo, permitindo que diálogos, narração, efeitos sonoros, música e elementos visuais sejam produzidos juntos em uma saída sincronizada.

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

O Vidu Q3 Turbo suporta durações de vídeo de 1 a 16 segundos por geração, dependendo do fluxo de trabalho e das configurações selecionados.

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

Escolha o Vidu Q3 Turbo quando a velocidade de geração e a iteração rápida forem prioridade. O Vidu Q3 padrão é geralmente direcionado a resultados narrativos de maior qualidade, onde a latência é menos importante.

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

Sim. O modelo oferece suporte a fluxos de trabalho de imagem para vídeo, permitindo que os usuários animem imagens estáticas em clipes em movimento, mantendo a consistência visual.

Can Vidu Q3 Turbo create videos in vertical formats for TikTok and Shorts?

Sim. A API suporta múltiplas proporções de aspecto, incluindo 9:16, tornando-a adequada para TikTok, YouTube Shorts e Instagram Reels.

What output resolutions are available in Vidu Q3 Turbo?

O Vidu Q3 Turbo suporta geração de vídeo em 540p, 720p e 1080p a 24 FPS.

What are the main limitations of the Vidu Q3 Turbo API?

O modelo é otimizado para geração de formato curto e, no momento, limita um único clipe a 16 segundos. Produções mais longas exigem a combinação de várias cenas geradas durante a edição.

Claude Opus 5 is now live on CometAPI →

Vidu Q3 Turbo

Por Segundo:$0.028

Lançado:May 31, 2026

Vidu Q3 Turbo é uma versão otimizada do Vidu Q3, projetada para uma geração de vídeos mais rápida. Mantém boa qualidade visual enquanto melhora significativamente a velocidade, tornando-o adequado para iterações rápidas e produção em larga escala.

Novo

Uso comercial

Especificações Técnicas do Vidu Q3 Turbo

Item	Vidu Q3 Turbo
Model ID	viduq3-turbo
Provider	Vidu
Model Family	Série Vidu Q3
Model Type	Geração de vídeo
Input Types	Texto, Imagem, Imagem inicial + Imagem final
Output Type	Vídeo com áudio sincronizado opcional
Resolution	540p, 720p, 1080p
Duration Range	1–16 segundos
Frame Rate	24 FPS
Audio Generation	Geração de áudio nativa
Text-to-Video	Suportado
Image-to-Video	Suportado
Start-End-to-Video	Suportado
Reference-to-Video	Suportado via fluxo de trabalho do Q3 Turbo
Aspect Ratios	16:9, 9:16, 3:4, 4:3, 1:1
Primary Focus	Geração de vídeo rápida e de baixa latência

O que é o Vidu Q3 Turbo?

Vidu Q3 Turbo é a versão otimizada para velocidade do modelo de geração de vídeo Vidu Q3. Ele é projetado para criadores e desenvolvedores que precisam de iteração rápida mantendo a saída de áudio e vídeo sincronizada. Ao contrário de modelos de vídeo anteriores que exigiam pipelines separados de produção de áudio, o Q3 Turbo pode gerar diálogos, narração, efeitos sonoros, música e vídeo juntos em um único fluxo de geração.

Principais Recursos do Vidu Q3 Turbo

Geração nativa de áudio e vídeo: Produz vídeo, diálogos, narração, efeitos sonoros e música juntos em uma saída sincronizada.
Pipeline de inferência rápido: Otimizado para menor latência que o Vidu Q3 padrão, preservando a consistência visual.
Suporte a geração de 16 segundos: Pode gerar clipes narrativos completos de até 16 segundos em uma única execução.
Múltiplos modos de criação: Suporta texto para vídeo, imagem para vídeo e geração de vídeo por quadros inicial/final.
Resoluções de saída flexíveis: Suporta geração em 540p, 720p e 1080p.
Controle de narrativa em nível de quadro: Suporta instruções detalhadas de movimento de câmera e ritmo para resultados cinematográficos.

Desempenho de Benchmark do Vidu Q3 Turbo

A Vidu não divulgou publicamente pontuações padronizadas de benchmark comparáveis a benchmarks de modelos de linguagem de IA como MMLU ou SWE-Bench. Em vez disso, a Vidu posiciona o Q3 Turbo em torno de métricas de produção:

Capacidade	Informado publicamente
Duração por geração	Até 16 segundos
Resolução	Até 1080p
Suporte a áudio nativo	Sim
Diálogo com vários locutores	Suportado
Geração de vídeo multilíngue	inglês, japonês, chinês

Como não foi publicado um ranking oficial de benchmarks para o Q3 Turbo, comparações independentes de benchmark não estão disponíveis no momento.

Vidu Q3 Turbo vs Vidu Q3 vs Kling 2.1

Feature	Vidu Q3 Turbo	Vidu Q3	Kling 2.1
Velocidade de geração	O mais rápido da família Q3	Foco em maior qualidade	Competitiva
Áudio nativo	Sim	Sim	Limitado, dependendo do fluxo de trabalho
Duração máxima	16s	16s	Varia
Resolução	Até 1080p	Até 1080p	Até 1080p
Texto para vídeo	Sim	Sim	Sim
Imagem para vídeo	Sim	Sim	Sim
Melhor para	Iteração rápida	Saída narrativa premium	Geração cinematográfica

Limitações Conhecidas

O comprimento máximo do clipe é de 16 segundos por geração.
Produções de longa duração exigem a junção de múltiplos clipes.
Não existe atualmente um conjunto de benchmarks padronizado disponível publicamente.
A qualidade pode ser ligeiramente inferior às variantes focadas em premium quando a velocidade máxima de geração é priorizada.

Casos de Uso Representativos

Produção de drama de curta duração

Gere cenas narrativas completas com fala sincronizada, efeitos sonoros e música.

Conteúdo para redes sociais

Crie rapidamente vídeos para TikTok, Reels, Shorts e anúncios com pós-produção mínima.

Storyboard e pré-visualização

Converta roteiros ou artes conceituais em sequências animadas para revisão criativa.

Vídeos de marketing

Produza demonstrações de produto, clipes promocionais e conteúdo narrativo de marca.

Animação de personagens

Anime imagens de referência preservando a consistência visual entre as cenas.

Notas da Versão do Modelo

Vidu Q3 Turbo pertence à geração Q3 de modelos Vidu e é posicionado como a alternativa de menor latência ao Q3 padrão. O modelo enfatiza a velocidade de produção, a geração de áudio sincronizado e fluxos de trabalho de narrativa focados no criador, mantendo suporte à saída de vídeo em 1080p e à geração de clipes de 16 segundos.

Como usar o Vidu Q3 Turbo na CometAPI

Ao usar o Vidu Q3 Turbo pela CometAPI, as aplicações normalmente enviam uma solicitação de geração de vídeo, recebem um identificador de tarefa, monitoram o status da tarefa de forma assíncrona e recuperam os recursos concluídos quando a geração termina.

Esse fluxo de trabalho é adequado para sistemas de produção, plataformas de conteúdo e pipelines de mídia automatizados.

Fluxo de trabalho

Autenticar-se na CometAPI
Enviar uma solicitação de geração do Vidu Q3 Turbo
Armazenar o identificador de tarefa retornado
Consultar periodicamente o status da tarefa ou usar fluxos de trabalho baseados em callback, se disponível
Recuperar os recursos de vídeo gerados após a conclusão

Monitore o status da tarefa até ge

FAQ

Preços para Vidu Q3 Turbo

Explore preços competitivos para Vidu Q3 Turbo, 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 Turbo 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 Turbo

Acesse código de exemplo abrangente e recursos de API para Vidu Q3 Turbo 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 Turbo em seus projetos.

POST

/v1/videos

# Create a video with viduq3-turbo
# 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-turbo" \
  -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 '
' | 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

cURL Code Example

# Create a video with viduq3-turbo
# 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-turbo" \
  -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

Python Code Example

# Create a video with viduq3-turbo 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-turbo"),
        "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-turbo 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-turbo");
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);
}

Versões do Vidu Q3 Turbo

O motivo pelo qual Vidu Q3 Turbo 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