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

Spécifications techniques de Vidu Q3

Élément	Vidu Q3 (viduq3-pro)
ID du modèle	viduq3-pro
Fournisseur	Vidu
Famille du modèle	Série Vidu Q3
Type de modèle	Génération vidéo par IA
Types d'entrée	Texte, Image, Image de début + image de fin
Type de sortie	Vidéo avec audio natif synchronisé
Résolution	540p, 720p, 1080p
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
Commutation intelligente des plans	Pris en charge
Objectif principal	Narration et création vidéo cinématographiques

Qu'est-ce que Vidu Q3 ?

Vidu Q3 est le modèle vidéo phare de troisième génération de Vidu, conçu spécifiquement pour la génération de vidéos axées sur la narration. Contrairement aux systèmes vidéo IA traditionnels qui génèrent d’abord les visuels puis l’audio, Vidu Q3 crée simultanément dialogues, narration, effets sonores, musique et vidéo, permettant une narration synchronisée directement à partir d’un flux de génération unique. Le modèle est conçu pour les drames courts, les séquences cinématographiques, les contenus publicitaires et les récits centrés sur les personnages.

Principales fonctionnalités de Vidu Q3

Synchronisation audio-vidéo native : génère des dialogues, une narration, des effets sonores et de la musique directement avec la vidéo.
Génération continue de 16 secondes : produit des clips narratifs complets en une seule exécution.
Contrôle de la caméra précis à l’image près : prend en charge un contrôle détaillé des mouvements de caméra, du rythme et de la composition des scènes.
Prise en charge de dialogues multi-locuteurs : conçu pour les conversations et les interactions entre personnages.
Génération multilingue : prend en charge la création de contenus en anglais, japonais et chinois.
Optimisation pour la narration cinématographique : spécialement réglé pour les drames, le style film, les comics et la publicité narrative.

Performances de référence de Vidu Q3

Contrairement aux modèles de langage, Vidu Q3 ne publie pas de scores de benchmarks standardisés tels que MMLU ou SWE-Bench. Les indicateurs de performance rendus publics incluent :

Indicateur	Informations publiques
Durée maximale	16 secondes
Résolution maximale	1080p
Génération audio native	Oui
Dialogue multi-locuteurs	Oui
Prise en charge multilingue	Anglais, Japonais, Chinois
Contrôle de la caméra au niveau de l’image	Oui

Score d’analyse artificielle de 1241 et classement parmi les principaux systèmes mondiaux de génération vidéo, bien que la validation par des benchmarks indépendants reste limitée.

Vidu Q3 vs Vidu Q3 Turbo vs Kling 2.1

Fonction	Vidu Q3	Vidu Q3 Turbo	Kling 2.1
Positionnement	Qualité premium	Optimisé pour la vitesse	Génération vidéo générale
Audio natif	Oui	Oui	Dépend du flux de travail
Durée max	16s	16s	Variable
Résolution	Jusqu’à 1080p	Jusqu’à 1080p	Jusqu’à 1080p
Contrôle de la caméra	Avancé	Avancé	Performant
Focalisation sur la narration	La plus élevée	Modérée	Forte
Vitesse de génération	Standard	Plus rapide	Compétitive

Limites connues

Les clips individuels restent limités à 16 secondes.
Les productions longues nécessitent de combiner plusieurs générations.
La transparence des benchmarks publics reste limitée par rapport aux principaux fournisseurs de LLM.
La qualité narrative dépend fortement de la conception des prompts et de la planification des scènes.

Cas d’utilisation représentatifs

Courts métrages IA

Générez des scènes cinématographiques avec paroles, ambiances et musique synchronisées.

Production de drames courts

Créez des contenus dramatiques sérialisés sans flux de production audio séparés.

Publicité et narration de marque

Produisez des publicités narratives avec voix off et design sonore intégrés.

Adaptation de comics et de mangas

Transformez des storyboards et des illustrations en clips narratifs animés.

Création de vidéos pour les réseaux sociaux

Générez des contenus TikTok, Shorts et Reels avec audio synchronisé prêt à publier.

Notes de version du modèle

Vidu Q3 représente la version premium de la famille Q3. Comparé à Vidu Q3 Turbo, le modèle Q3 standard privilégie la qualité de sortie, la cohérence narrative et la narration cinématographique plutôt que la vitesse de génération. Les deux modèles prennent en charge la sortie audio-vidéo native et la génération de vidéos jusqu’à 16 secondes.

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

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

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

Étape 2 : Testez gratuitement l’API viduq3 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é de sortie, de tester des astuces ou des entrées d’image, et de mieux comprendre les performances de l’API HappyHorse-1.0 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 propre 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ù l’accès stable et l’intégration pratique sont essentiels.

Tarification pour Vidu Q3

Découvrez des tarifs compétitifs pour Vidu Q3, 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 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

Accédez à des exemples de code complets et aux ressources API pour Vidu Q3 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 dans vos projets.

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

Versions de Vidu Q3

La raison pour laquelle Vidu Q3 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
viduq3-turbo

Vidu Q3