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

Specifiche tecniche di Vidu Q3

Voce	Vidu Q3 (viduq3-pro)
ID del modello	viduq3-pro
Fornitore	Vidu
Famiglia di modelli	Serie Vidu Q3
Tipo di modello	Generazione video con IA
Tipi di input	Testo, Immagine, Immagine iniziale + immagine finale
Tipo di output	Video con audio nativo sincronizzato
Risoluzione	540p, 720p, 1080p
Durata	1–16 secondi
Frame rate	24 FPS
Generazione audio	Generazione audio-video nativa
Da testo a video	Supportato
Da immagine a video	Supportato
Da immagine iniziale e finale a video	Supportato
Cambio di inquadratura intelligente	Supportato
Focus principale	Narrazione e creazione video di stile cinematografico

Che cos'è Vidu Q3?

Vidu Q3 è il modello video di punta di terza generazione di Vidu, progettato specificamente per la generazione video guidata dalla storia. A differenza dei sistemi video IA tradizionali che generano prima i visual e poi l’audio, Vidu Q3 crea dialoghi, narrazione, effetti sonori, musica e video simultaneamente, consentendo uno storytelling sincronizzato direttamente in un flusso di generazione unico. Il modello è pensato per corti drammatici, sequenze cinematografiche, contenuti pubblicitari e narrazioni incentrate sui personaggi.

Caratteristiche principali di Vidu Q3

Sincronizzazione audio-video nativa: genera dialoghi, narrazione, effetti sonori e musica direttamente insieme al video.
Generazione continua di 16 secondi: produce clip narrative complete in un’unica esecuzione di generazione.
Controllo della camera con precisione al frame: supporta un controllo dettagliato del movimento della camera, del ritmo e della composizione della scena.
Supporto al dialogo multi-speaker: progettato per conversazioni e interazioni tra personaggi.
Generazione multilingue: supporta contenuti in inglese, giapponese e cinese.
Ottimizzazione per storytelling cinematografico: ottimizzato specificamente per drama, contenuti in stile film, fumetti e pubblicità narrative.

Prestazioni di benchmark di Vidu Q3

A differenza dei modelli linguistici, Vidu Q3 non pubblica punteggi di benchmark standardizzati come MMLU o SWE-Bench. Gli indicatori di prestazione divulgati pubblicamente includono:

Metrica	Informazioni pubbliche
Durata massima	16 secondi
Risoluzione massima	1080p
Generazione audio nativa	Sì
Dialogo multi-speaker	Sì
Supporto multilingue	Inglese, giapponese, cinese
Controllo camera a livello di frame	Sì

Punteggio Artificial Analysis di 1241 e posizionamento tra i principali sistemi globali di generazione video, sebbene la validazione indipendente dei benchmark resti limitata.

Vidu Q3 vs Vidu Q3 Turbo vs Kling 2.1

Caratteristica	Vidu Q3	Vidu Q3 Turbo	Kling 2.1
Posizionamento	Qualità premium	Ottimizzato per la velocità	Generazione video generica
Audio nativo	Sì	Sì	Dipende dal workflow
Durata massima	16s	16s	Variabile
Risoluzione	Fino a 1080p	Fino a 1080p	Fino a 1080p
Controllo camera	Avanzato	Avanzato	Solido
Focus narrativo	Massimo	Moderato	Solido
Velocità di generazione	Standard	Più veloce	Competitiva

Limitazioni note

Le singole clip restano limitate a 16 secondi.
Le produzioni long-form richiedono la combinazione di più generazioni.
La trasparenza dei benchmark pubblici resta limitata rispetto ai principali provider di LLM.
La qualità narrativa dipende fortemente dal prompt design e dalla pianificazione delle scene.

Casi d'uso rappresentativi

Cortometraggi IA

Genera scene cinematografiche con parlato, suoni ambientali e musica sincronizzati.

Produzione di brevi drammi

Crea contenuti drammatici serializzati senza flussi di lavoro separati per la produzione audio.

Pubblicità e storytelling di brand

Produci spot narrativi con voiceover e sound design integrati.

Adattamento di fumetti e manga

Trasforma storyboard e illustrazioni in clip narrative animate.

Genera contenuti per TikTok, Shorts e Reels con audio sincronizzato pronto per la pubblicazione.

Note sulla versione del modello

Vidu Q3 rappresenta la versione premium della famiglia Q3. Rispetto a Vidu Q3 Turbo, il modello Q3 standard dà priorità alla qualità dell’output, alla coerenza narrativa e allo storytelling cinematografico piuttosto che alla velocità di generazione. Entrambi i modelli supportano l’output audio-video nativo e la generazione di video fino a 16 secondi.

Come accedere e distribuire l'API viduq3 su CometAPI

Passaggio 1: Registrati o accedi a CometAPI e ottieni la tua chiave API viduq3

Crea un account CometAPI o accedi a un account esistente per accedere all’API una volta disponibile (HappyHorse-1.0 API). Dopo il rilascio, potrai ottenere una chiave API HappyHorse-1.0 dalla piattaforma ed essere pronto per test o integrazione.

Passaggio 2: Prova gratuitamente l'API viduq3 nel playground

Prima della distribuzione, puoi provare direttamente l’API viduq3 nel playground di CometAPI. Questo offre un modo semplice per esplorare la qualità dell’output, testare suggerimenti o input di immagine e ottenere una comprensione più chiara delle prestazioni dell’API HappyHorse-1.0 prima di usarla in produzione.

Passaggio 3: Distribuisci l'API viduq3 in produzione

Dopo i test, il passo successivo è distribuire l’API viduq3 nella tua applicazione, prodotto o ambiente interno. Ciò ti consente di utilizzare l’API viduq3 in scenari reali di generazione video in cui accesso stabile e integrazione pratica sono fondamentali.

Prezzi per Vidu Q3

Esplora i prezzi competitivi per Vidu Q3, progettato per adattarsi a vari budget e necessità di utilizzo. I nostri piani flessibili garantiscono che paghi solo per quello che usi, rendendo facile scalare man mano che i tuoi requisiti crescono. Scopri come Vidu Q3 può migliorare i tuoi progetti mantenendo i costi gestibili.

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

Codice di esempio e API per Vidu Q3

Accedi a codice di esempio completo e risorse API per Vidu Q3 per semplificare il tuo processo di integrazione. La nostra documentazione dettagliata fornisce una guida passo dopo passo, aiutandoti a sfruttare appieno il potenziale di Vidu Q3 nei tuoi progetti.

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

Versioni di Vidu Q3

Il motivo per cui Vidu Q3 dispone di più snapshot può includere fattori potenziali come variazioni nell'output dopo aggiornamenti che richiedono snapshot precedenti per coerenza, offrire agli sviluppatori un periodo di transizione per l'adattamento e la migrazione, e diversi snapshot corrispondenti a endpoint globali o regionali per ottimizzare l'esperienza utente. Per le differenze dettagliate tra le versioni, si prega di fare riferimento alla documentazione ufficiale.

version
viduq3
viduq3-turbo

Vidu Q3