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

Yes. Vidu Q3 Turbo supports native audio-video generation, allowing dialogue, narration, sound effects, music, and visuals to be produced together in a synchronized output.

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

Vidu Q3 Turbo supports video durations from 1 to 16 seconds per generation, depending on the selected workflow and settings.

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

Choose Vidu Q3 Turbo when generation speed and rapid iteration are priorities. Standard Vidu Q3 is generally positioned toward higher-quality narrative outputs where latency is less important.

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

Yes. The model supports image-to-video workflows, enabling users to animate still images into motion clips while maintaining visual consistency.

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

Yes. The API supports multiple aspect ratios including 9:16, making it suitable for TikTok, YouTube Shorts, and Instagram Reels.

What output resolutions are available in Vidu Q3 Turbo?

Vidu Q3 Turbo supports 540p, 720p, and 1080p video generation at 24 FPS.

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

The model is optimized for short-form generation and currently limits a single clip to 16 seconds. Longer productions require combining multiple generated scenes during editing.

API Vidu Q3 Turbo Acessível | text-to-video

Especificações Técnicas do Vidu Q3 Turbo

Item	Vidu Q3 Turbo
Model ID	viduq3-turbo
Provider	Vidu
Model Family	Vidu Q3 Series
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 nativa de áudio e vídeo
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 foi projetado para criadores e desenvolvedores que precisam de iteração rápida mantendo a saída de áudio e vídeo sincronizados. Diferentemente 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 trabalho 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 do 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 com quadro 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 em benchmarks do Vidu Q3 Turbo

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

Capacidade	Reportado publicamente
Duração por geração única	Até 16 segundos
Resolução	Até 1080p
Suporte nativo a áudio	Sim
Diálogo com múltiplos locutores	Suportado
Geração de vídeo multilíngue	Inglês, Japonês, Chinês

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

Vidu Q3 Turbo vs Vidu Q3 vs Kling 2.1

Recurso	Vidu Q3 Turbo	Vidu Q3	Kling 2.1
Velocidade de geração	Mais rápido da família Q3	Foco em qualidade superior	Competitiva
Áudio nativo	Sim	Sim	Limitado, dependendo do fluxo
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
Ideal 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 longas exigem a junção de vários clipes.
Atualmente não existe um conjunto padronizado de benchmarks disponível publicamente.
A qualidade pode ser ligeiramente inferior à de variantes focadas em premium quando a velocidade máxima de geração é priorizada.

Casos de uso representativos

Produção de drama curto

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

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 arte conceitual em sequências animadas para revisão criativa.

Vídeos de marketing

Produza vitrines de produtos, clipes promocionais e narrativas 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 dos modelos Vidu e está posicionado como a alternativa de menor latência ao Q3 padrão. O modelo enfatiza velocidade de produção, geração de áudio sincronizado e fluxos de trabalho de storytelling focados no criador, mantendo suporte a saída em 1080p e geração de clipes de 16 segundos.

Como acessar e implantar a viduq3 Turbo API no CometAPI

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

Passo 2: Teste gratuitamente a viduq3 Turbo API no Playground

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

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

Após os testes, o próximo passo é implantar a viduq3 API em seu próprio aplicativo, produto ou ambiente interno. Isso permite usar a viduq3 API 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 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.

Python
JavaScript
Curl

# 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("
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-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);
}

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

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

Vidu Q3 Turbo