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 de Vidu Q3 Turbo Asequible | text-to-video

Especificaciones técnicas de Vidu Q3 Turbo

Elemento	Vidu Q3 Turbo
ID del modelo	viduq3-turbo
Proveedor	Vidu
Familia del modelo	Vidu Q3 Series
Tipo de modelo	Generación de video
Tipos de entrada	Texto, imagen, imagen inicial + imagen final
Tipo de salida	Video con audio sincronizado opcional
Resolución	540p, 720p, 1080p
Intervalo de duración	1–16 segundos
Velocidad de fotogramas	24 FPS
Generación de audio	Generación nativa de audio y video
Texto a video	Compatible
Imagen a video	Compatible
Inicio–fin a video	Compatible
Referencia a video	Compatible a través del flujo de trabajo de Q3 Turbo
Relaciones de aspecto	16:9, 9:16, 3:4, 4:3, 1:1
Enfoque principal	Generación de video rápida y de baja latencia

¿Qué es Vidu Q3 Turbo?

Vidu Q3 Turbo es la versión optimizada para velocidad del modelo de generación de video Vidu Q3. Está diseñada para creadores y desarrolladores que necesitan iterar rápidamente manteniendo la sincronización entre audio y video. A diferencia de modelos de video anteriores que requerían flujos de producción de audio separados, Q3 Turbo puede generar diálogos, narración, efectos de sonido, música y video juntos en un único flujo de generación.

Características principales de Vidu Q3 Turbo

Generación nativa de audio y video: Produce video, diálogos, narración, efectos de sonido y música juntos en una salida sincronizada.
Canal de inferencia rápido: Optimizado para menor latencia que Vidu Q3 estándar, preservando la consistencia visual.
Compatibilidad con generación de 16 segundos: Puede generar clips narrativos completos de hasta 16 segundos en una sola ejecución.
Múltiples modos de creación: Admite texto a video, imagen a video y generación de video a partir de fotogramas inicial y final.
Resoluciones de salida flexibles: Admite generación en 540p, 720p y 1080p.
Control de la narración a nivel de fotograma: Admite instrucciones detalladas de movimiento de cámara y ritmo para resultados cinematográficos.

Rendimiento de referencia de Vidu Q3 Turbo

Vidu no ha publicado puntuaciones estandarizadas comparables a los benchmarks de modelos de lenguaje de IA como MMLU o SWE-Bench. En su lugar, Vidu posiciona Q3 Turbo en torno a métricas de producción:

Capacidad	Reportado públicamente
Duración de una sola generación	Hasta 16 segundos
Resolución	Hasta 1080p
Compatibilidad con audio nativo	Sí
Diálogo con múltiples voces	Compatible
Generación de video multilingüe	Inglés, japonés, chino

Dado que no se ha publicado una tabla de clasificación oficial para Q3 Turbo, actualmente no hay disponibles comparaciones de benchmarks independientes.

Vidu Q3 Turbo vs Vidu Q3 vs Kling 2.1

Característica	Vidu Q3 Turbo	Vidu Q3	Kling 2.1
Velocidad de generación	La más rápida de la familia Q3	Enfoque en mayor calidad	Competitiva
Audio nativo	Sí	Sí	Limitado según el flujo de trabajo
Duración máxima	16s	16s	Variable
Resolución	Hasta 1080p	Hasta 1080p	Hasta 1080p
Texto a video	Sí	Sí	Sí
Imagen a video	Sí	Sí	Sí
Ideal para	Iteración rápida	Salida narrativa de nivel premium	Generación cinematográfica

Limitaciones conocidas

La longitud máxima del clip es de 16 segundos por generación.
Las producciones de formato largo requieren unir varios clips.
Actualmente no existe un conjunto de benchmarks estandarizados disponible públicamente.
La calidad puede ser ligeramente inferior a la de las variantes centradas en calidad premium cuando se prioriza la máxima velocidad de generación.

Casos de uso representativos

Producción de drama corto

Genere escenas narrativas completas con voz sincronizada, efectos de sonido y música.

Contenido para redes sociales

Cree rápidamente videos para TikTok, Reels, Shorts y publicidad con mínima posproducción.

Creación de guiones gráficos y previsualización

Convierta guiones o arte conceptual en secuencias animadas para revisión creativa.

Videos de marketing

Produzca demostraciones de producto, clips promocionales y narrativas de marca.

Animación de personajes

Anime imágenes de referencia preservando la consistencia visual entre escenas.

Notas de la versión del modelo

Vidu Q3 Turbo pertenece a la generación Q3 de modelos Vidu y se posiciona como la alternativa de menor latencia al Q3 estándar. El modelo enfatiza la velocidad de producción, la generación de audio sincronizado y flujos de trabajo de narración orientados al creador, al tiempo que mantiene compatibilidad con salida de video a 1080p y generación de clips de 16 segundos.

Cómo acceder e implementar la API de viduq3 Turbo en CometAPI

Paso 1: Regístrese o inicie sesión en CometAPI y obtenga su clave de API de viduq3 Turbo

Cree su cuenta de CometAPI o inicie sesión en una cuenta existente para acceder a la API una vez que esté disponible (API de viduq3 Turbo). Tras el lanzamiento, podrá obtener una clave de API de HappyHorse-1.0 desde la plataforma y estar listo para pruebas o integración.

Paso 2: Pruebe la API de viduq3 Turbo gratis en el Playground

Antes de la implementación, puede probar la API de viduq3 directamente en el Playground de CometAPI. Esto ofrece una manera sencilla de explorar la calidad de salida, probar sugerencias o entradas de imagen, y obtener una comprensión más clara del rendimiento de la API de viduq3 Turbo antes de usarla en producción.

Paso 3: Implemente la API de viduq3 en producción

Después de las pruebas, el siguiente paso es implementar la API de viduq3 en su propia aplicación, producto o entorno interno. Esto le permite usar la API de viduq3 en escenarios reales de generación de video donde el acceso estable y la integración práctica son cruciales.

Precios para Vidu Q3 Turbo

Explora precios competitivos para Vidu Q3 Turbo, diseñado para adaptarse a diversos presupuestos y necesidades de uso. Nuestros planes flexibles garantizan que solo pagues por lo que uses, facilitando el escalado a medida que crecen tus requisitos. Descubre cómo Vidu Q3 Turbo puede mejorar tus proyectos mientras mantienes los costos manejables.

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 ejemplo y API para Vidu Q3 Turbo

Accede a código de muestra completo y recursos de API para Vidu Q3 Turbo para agilizar tu proceso de integración. Nuestra documentación detallada proporciona orientación paso a paso, ayudándote a aprovechar todo el potencial de Vidu Q3 Turbo en tus proyectos.

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

Versiones de Vidu Q3 Turbo

La razón por la cual Vidu Q3 Turbo tiene múltiples instantáneas puede incluir factores potenciales como variaciones en la salida tras actualizaciones que requieren instantáneas anteriores para mantener la coherencia, ofrecer a los desarrolladores un período de transición para adaptación y migración, y diferentes instantáneas que corresponden a endpoints globales o regionales para optimizar la experiencia del usuario. Para conocer las diferencias detalladas entre versiones, consulte la documentación oficial.

version
viduq3-turbo

Vidu Q3 Turbo