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

Specifiche tecniche di Vidu Q3 Turbo

Voce	Vidu Q3 Turbo
Model ID	viduq3-turbo
Provider	Vidu
Model Family	Serie Vidu Q3
Model Type	Generazione video
Input Types	Testo, Immagine, Immagine iniziale + Immagine finale
Output Type	Video con audio sincronizzato opzionale
Resolution	540p, 720p, 1080p
Duration Range	1–16 secondi
Frame Rate	24 FPS
Audio Generation	Generazione audio-video nativa
Text-to-Video	Supportato
Image-to-Video	Supportato
Start-End-to-Video	Supportato
Reference-to-Video	Supportato tramite il flusso di lavoro Q3 Turbo
Aspect Ratios	16:9, 9:16, 3:4, 4:3, 1:1
Primary Focus	Generazione video rapida e a bassa latenza

Che cos'è Vidu Q3 Turbo?

Vidu Q3 Turbo è la versione ottimizzata per la velocità del modello di generazione video Vidu Q3. È progettato per creator e sviluppatori che necessitano di iterazioni rapide mantenendo un output audio-video sincronizzato. A differenza dei modelli video precedenti che richiedevano pipeline di produzione audio separate, Q3 Turbo può generare dialoghi, narrazione, effetti sonori, musica e video insieme in un unico flusso di generazione.

Caratteristiche principali di Vidu Q3 Turbo

Generazione audio-video nativa: produce video, dialoghi, narrazione, effetti sonori e musica insieme in un output sincronizzato.
Pipeline di inferenza rapida: ottimizzata per una latenza inferiore rispetto al Vidu Q3 standard, preservando la coerenza visiva.
Supporto per generazioni da 16 secondi: può generare clip narrative complete fino a 16 secondi in un'unica esecuzione.
Modalità di creazione multiple: supporta da testo a video, da immagine a video e generazione video da immagine iniziale/finale.
Risoluzioni di output flessibili: supporta la generazione a 540p, 720p e 1080p.
Controllo della narrazione a livello di fotogramma: supporta istruzioni dettagliate sui movimenti di camera e sui tempi per risultati cinematografici.

Prestazioni nei benchmark di Vidu Q3 Turbo

Vidu non ha rilasciato pubblicamente punteggi di benchmark standardizzati paragonabili ai benchmark dei modelli linguistici di IA come MMLU o SWE-Bench. Invece, Vidu posiziona Q3 Turbo in base a metriche di produzione:

Capacità	Pubblicamente riportato
Durata per singola generazione	Fino a 16 secondi
Risoluzione	Fino a 1080p
Supporto audio nativo	Sì
Dialoghi multi-speaker	Supportato
Generazione video multilingue	inglese, giapponese, cinese

Poiché non è stata pubblicata alcuna classifica ufficiale di benchmark per Q3 Turbo, confronti di benchmark indipendenti non sono attualmente disponibili.

Vidu Q3 Turbo vs Vidu Q3 vs Kling 2.1

Caratteristica	Vidu Q3 Turbo	Vidu Q3	Kling 2.1
Velocità di generazione	La più veloce della famiglia Q3	Maggior focus sulla qualità	Competitiva
Audio nativo	Sì	Sì	Limitato a seconda del flusso di lavoro
Durata massima	16s	16s	Varia
Risoluzione	Fino a 1080p	Fino a 1080p	Fino a 1080p
Da testo a video	Sì	Sì	Sì
Da immagine a video	Sì	Sì	Sì
Ideale per	Iterazione rapida	Output narrativo premium	Generazione cinematografica

Limitazioni note

La lunghezza massima della clip è di 16 secondi per generazione.
Le produzioni long-form richiedono l'unione di più clip.
Non esiste attualmente una suite di benchmark standardizzata disponibile pubblicamente.
La qualità può essere leggermente inferiore rispetto alle varianti orientate al premium quando si privilegia la massima velocità di generazione.

Casi d'uso rappresentativi

Produzione di corti drammatici

Genera scene narrative complete con parlato, effetti sonori e musica sincronizzati.

Crea rapidamente video per TikTok, Reels, Shorts e pubblicità con post-produzione minima.

Creazione di storyboard e previsualizzazione

Converte sceneggiature o concept art in sequenze animate per la revisione creativa.

Video di marketing

Produce presentazioni di prodotto, clip promozionali e contenuti di storytelling di brand.

Animazione dei personaggi

Anima immagini di riferimento preservando la coerenza visiva tra le scene.

Note sulla versione del modello

Vidu Q3 Turbo appartiene alla generazione Q3 dei modelli Vidu ed è posizionato come alternativa a latenza inferiore rispetto al Q3 standard. Il modello enfatizza la velocità di produzione, la generazione audio sincronizzata e workflow di storytelling orientati ai creator, mantenendo il supporto per output video a 1080p e la generazione di clip da 16 secondi.

Come accedere e distribuire l'API viduq3 Turbo su CometAPI

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

Crea il tuo account CometAPI o accedi a un account esistente per accedere all'API una volta disponibile (viduq3 Turbo 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 Turbo nel Playground

Prima della distribuzione, puoi provare l'API viduq3 direttamente nel Playground di CometAPI. Questo fornisce un modo semplice per esplorare la qualità dell'output, testare suggerimenti o input di immagini e ottenere una comprensione più chiara delle prestazioni dell'API viduq3 Turbo prima di utilizzarla in produzione.

Passaggio 3: Distribuisci l'API viduq3 in produzione

Dopo i test, il passo successivo è distribuire l'API viduq3 nella tua applicazione, nel tuo prodotto o nel tuo ambiente interno. Questo ti permette di utilizzare l'API viduq3 in scenari reali di generazione video in cui accesso stabile e integrazione pratica sono cruciali.

Prezzi per Vidu Q3 Turbo

Esplora i prezzi competitivi per Vidu Q3 Turbo, 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 Turbo 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 Turbo

Accedi a codice di esempio completo e risorse API per Vidu Q3 Turbo 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 Turbo nei tuoi progetti.

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

Versioni di Vidu Q3 Turbo

Il motivo per cui Vidu Q3 Turbo 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-turbo

Vidu Q3 Turbo