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 Abordable | text-to-video

Caractéristiques techniques de Vidu Q3 Turbo

Élément	Vidu Q3 Turbo
ID du modèle	viduq3-turbo
Fournisseur	Vidu
Famille de modèles	Vidu Q3 Series
Type de modèle	Génération vidéo
Types d'entrée	Texte, Image, Image de début + Image de fin
Type de sortie	Vidéo avec audio synchronisé facultatif
Résolution	540p, 720p, 1080p
Plage de durée	1–16 secondes
Fréquence d’images	24 FPS
Génération audio	Génération audio‑vidéo native
Texte‑vers‑vidéo	Pris en charge
Image‑vers‑vidéo	Pris en charge
Début‑fin vers vidéo	Pris en charge
Référence‑vers‑vidéo	Pris en charge via le workflow Q3 Turbo
Rapports d’aspect	16:9, 9:16, 3:4, 4:3, 1:1
Objectif principal	Génération vidéo rapide et à faible latence

Qu’est-ce que Vidu Q3 Turbo ?

Vidu Q3 Turbo est la version optimisée pour la vitesse du modèle de génération vidéo Vidu Q3. Il est conçu pour les créateurs et développeurs qui ont besoin d’itérer rapidement tout en conservant une sortie audio‑vidéo synchronisée. Contrairement aux modèles vidéo antérieurs qui nécessitaient des pipelines de production audio distincts, Q3 Turbo peut générer les dialogues, la narration, les effets sonores, la musique et la vidéo ensemble au sein d’un seul workflow de génération.

Principales fonctionnalités de Vidu Q3 Turbo

Génération audio‑vidéo native : Produit la vidéo, les dialogues, la narration, les effets sonores et la musique ensemble dans une sortie synchronisée.
Pipeline d’inférence rapide : Optimisé pour une latence inférieure à celle du Vidu Q3 standard tout en préservant la cohérence visuelle.
Prise en charge de générations de 16 secondes : Peut générer des séquences narratives complètes jusqu’à 16 secondes en un seul passage.
Multiples modes de création : Prend en charge le texte‑vers‑vidéo, l’image‑vers‑vidéo et la génération à partir d’images de début/fin.
Résolutions de sortie flexibles : Prend en charge des générations en 540p, 720p et 1080p.
Contrôle de la narration au niveau de l’image : Prend en charge des instructions détaillées de mouvement de caméra et de rythme pour des rendus cinématographiques.

Performances de référence de Vidu Q3 Turbo

Vidu n’a pas publié de scores de référence standardisés comparables aux benchmarks des modèles de langage IA tels que MMLU ou SWE‑Bench. Vidu positionne plutôt Q3 Turbo autour de métriques de production :

Capacité	Déclaré publiquement
Durée d’une génération unique	Jusqu’à 16 secondes
Résolution	Jusqu’à 1080p
Prise en charge audio native	Oui
Dialogue multi‑locuteurs	Pris en charge
Génération vidéo multilingue	anglais, japonais, chinois

Aucun classement officiel de benchmarks n’ayant été publié pour Q3 Turbo, des comparaisons indépendantes ne sont actuellement pas disponibles.

Vidu Q3 Turbo vs Vidu Q3 vs Kling 2.1

Fonctionnalité	Vidu Q3 Turbo	Vidu Q3	Kling 2.1
Vitesse de génération	La plus rapide de la famille Q3	Accent sur une qualité supérieure	Compétitive
Audio natif	Oui	Oui	Limitée selon le workflow
Durée max	16s	16s	Variable
Résolution	Jusqu’à 1080p	Jusqu’à 1080p	Jusqu’à 1080p
Texte‑vers‑vidéo	Oui	Oui	Oui
Image‑vers‑vidéo	Oui	Oui	Oui
Idéal pour	Itération rapide	Sortie narrative haut de gamme	Génération cinématographique

Limitations connues

La durée maximale d’un clip est de 16 secondes par génération.
Les productions longues nécessitent d’assembler plusieurs clips.
Aucune suite de benchmarks standardisée n’est actuellement disponible publiquement.
La qualité peut être légèrement inférieure à celle des variantes axées sur le haut de gamme lorsque la vitesse de génération maximale est privilégiée.

Cas d’utilisation représentatifs

Production de courts‑métrages dramatiques

Générez des scènes narratives complètes avec voix synchronisée, effets sonores et musique.

Contenus pour les réseaux sociaux

Créez rapidement des vidéos TikTok, Reels, Shorts et publicitaires avec un minimum de post‑production.

Storyboard et prévisualisation

Convertissez des scénarios ou des concept art en séquences animées pour examen créatif.

Vidéos marketing

Produisez des démonstrations de produits, des clips promotionnels et des contenus narratifs de marque.

Animation de personnages

Animez des images de référence tout en préservant la cohérence visuelle entre les scènes.

Notes de version du modèle

Vidu Q3 Turbo appartient à la génération Q3 des modèles Vidu et se positionne comme l’alternative à plus faible latence au Q3 standard. Le modèle met l’accent sur la vitesse de production, la génération audio synchronisée et des workflows de narration orientés créateurs, tout en conservant la prise en charge de la sortie vidéo 1080p et de la génération de clips de 16 secondes.

Comment accéder et déployer l’API viduq3 Turbo sur CometAPI

Étape 1 : Inscrivez‑vous ou connectez‑vous à CometAPI et obtenez votre clé API viduq3 Turbo

Créez votre compte CometAPI ou connectez‑vous à un compte existant pour accéder à l’API une fois qu’elle sera disponible (API viduq3 Turbo). Après la sortie, vous pourrez obtenir une clé API HappyHorse‑1.0 depuis la plateforme et serez prêt pour les tests ou l’intégration.

Étape 2 : Testez gratuitement l’API viduq3 Turbo dans le Playground

Avant le déploiement, vous pouvez essayer l’API viduq3 directement dans le Playground de CometAPI. Cela offre un moyen simple d’explorer la qualité des sorties, de tester des prompts ou des entrées d’images, et de mieux comprendre les performances de l’API viduq3 Turbo avant de l’utiliser en production.

Étape 3 : Déployez l’API viduq3 en production

Après les tests, l’étape suivante consiste à déployer l’API viduq3 dans votre application, produit ou environnement interne. Cela vous permet d’utiliser l’API viduq3 dans des scénarios réels de génération vidéo où un accès stable et une intégration pratique sont essentiels.

Tarification pour Vidu Q3 Turbo

Découvrez des tarifs compétitifs pour Vidu Q3 Turbo, conçus pour s'adapter à différents budgets et besoins d'utilisation. Nos formules flexibles garantissent que vous ne payez que ce que vous utilisez, ce qui facilite l'adaptation à mesure que vos besoins évoluent. Découvrez comment Vidu Q3 Turbo peut améliorer vos projets tout en maîtrisant les coûts.

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).

Exemple de code et API pour Vidu Q3 Turbo

Accédez à des exemples de code complets et aux ressources API pour Vidu Q3 Turbo afin de simplifier votre processus d'intégration. Notre documentation détaillée fournit des instructions étape par étape pour vous aider à exploiter tout le potentiel de Vidu Q3 Turbo dans vos projets.

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

Versions de Vidu Q3 Turbo

La raison pour laquelle Vidu Q3 Turbo dispose de plusieurs instantanés peut inclure des facteurs potentiels tels que des variations de sortie après des mises à jour nécessitant des instantanés plus anciens pour la cohérence, offrant aux développeurs une période de transition pour l'adaptation et la migration, et différents instantanés correspondant à des points de terminaison globaux ou régionaux pour optimiser l'expérience utilisateur. Pour les différences détaillées entre les versions, veuillez consulter la documentation officielle.

version
viduq3-turbo

Vidu Q3 Turbo