Can the Vidu Q3 Turbo API generate video and audio at the same time?

Sì. Vidu Q3 Turbo supporta la generazione audio-video nativa, consentendo di produrre insieme dialoghi, narrazione, effetti sonori, musica ed elementi visivi in un output sincronizzato.

What is the maximum video length supported by Vidu Q3 Turbo API?

Vidu Q3 Turbo supporta durate video da 1 a 16 secondi per generazione, a seconda del flusso di lavoro e delle impostazioni selezionati.

When should I use Vidu Q3 Turbo instead of Vidu Q3?

Scegli Vidu Q3 Turbo quando la velocità di generazione e l'iterazione rapida sono priorità. Standard Vidu Q3 è in genere orientato a output narrativi di qualità superiore, dove la latenza è meno importante.

Does the Vidu Q3 Turbo API support image-to-video generation?

Sì. Il modello supporta flussi di lavoro da immagine a video, consentendo agli utenti di animare immagini statiche in clip in movimento mantenendo la coerenza visiva.

Can Vidu Q3 Turbo create videos in vertical formats for TikTok and Shorts?

Sì. L'API supporta più rapporti d'aspetto, tra cui 9:16, rendendola adatta a TikTok, YouTube Shorts e Instagram Reels.

What output resolutions are available in Vidu Q3 Turbo?

Vidu Q3 Turbo supporta la generazione video a 540p, 720p e 1080p a 24 FPS.

What are the main limitations of the Vidu Q3 Turbo API?

Il modello è ottimizzato per la generazione di formati brevi e attualmente limita una singola clip a 16 secondi. Le produzioni più lunghe richiedono di combinare più scene generate in fase di montaggio.

API Vidu Q3 Turbo Conveniente | text-to-video

Specifiche tecniche di Vidu Q3 Turbo

Voce	Vidu Q3 Turbo
ID modello	viduq3-turbo
Fornitore	Vidu
Famiglia del modello	Serie Vidu Q3
Tipo di modello	Generazione video
Tipi di input	Testo, immagine, immagine iniziale + immagine finale
Tipo di output	Video con audio sincronizzato opzionale
Risoluzione	540p, 720p, 1080p
Intervallo di durata	1–16 secondi
Frequenza dei fotogrammi	24 FPS
Generazione audio	Generazione nativa audio-video
Da testo a video	Supportato
Da immagine a video	Supportato
Da fotogramma iniziale/finale a video	Supportato
Da riferimento a video	Supportato tramite workflow Q3 Turbo
Rapporti d'aspetto	16:9, 9:16, 3:4, 4:3, 1:1
Obiettivo principale	Generazione video rapida 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 developer che necessitano di iterazioni rapide mantenendo un output audio-video sincronizzato. A differenza dei modelli video precedenti che richiedevano pipeline audio separate, Q3 Turbo può generare dialoghi, narrazione, effetti sonori, musica e video insieme in un unico workflow di generazione.

Caratteristiche principali di Vidu Q3 Turbo

Generazione nativa audio-video: Produce video, dialoghi, narrazione, effetti sonori e musica insieme in un output sincronizzato.
Pipeline di inferenza veloce: Ottimizzata per latenza inferiore rispetto al Vidu Q3 standard, preservando la coerenza visiva.
Supporto per generazioni di 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 fotogrammi iniziale/finale.
Risoluzioni di output flessibili: Supporta generazione a 540p, 720p e 1080p.
Controllo della narrazione a livello di fotogramma: Supporta istruzioni dettagliate su movimenti di camera e ritmo per output cinematografici.

Prestazioni benchmark di Vidu Q3 Turbo

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

Capacità	Dichiarato pubblicamente
Durata per singola generazione	Fino a 16 secondi
Risoluzione	Fino a 1080p
Supporto audio nativo	Sì
Dialoghi multi-voce	Supportato
Generazione video multilingue	Inglese, Giapponese, Cinese

Poiché non è stata pubblicata una classifica ufficiale di benchmark per Q3 Turbo, al momento non sono disponibili confronti indipendenti.

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	Focalizzato su qualità più alta	Competitiva
Audio nativo	Sì	Sì	Limitato a seconda del workflow
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 è 16 secondi per generazione.
Le produzioni di lunga durata richiedono l’unione di più clip.
Attualmente non esiste una suite di benchmark standardizzata pubblicamente disponibile.
La qualità può essere leggermente inferiore rispetto alle varianti focalizzate sul premium quando si privilegia la massima velocità di generazione.

Casi d'uso rappresentativi

Produzione di cortometraggi drammatici

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

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

Storyboard e previsualizzazione

Converti script o concept art in sequenze animate per la revisione creativa.

Video di marketing

Produci presentazioni di prodotto, clip promozionali e 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 l’alternativa a bassa latenza 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 generazione di clip da 16 secondi.

Come usare Vidu Q3 Turbo su CometAPI

Quando si utilizza Vidu Q3 Turbo tramite CometAPI, le applicazioni in genere inviano una richiesta di generazione video, ricevono un identificatore di task, monitorano lo stato del task in modo asincrono e recuperano gli asset completati una volta terminata la generazione.

Questo workflow è adatto a sistemi di produzione, piattaforme di contenuti e pipeline multimediali automatizzate.

Flusso di lavoro

Autenticati con CometAPI
Invia una richiesta di generazione Vidu Q3 Turbo
Memorizza l’identificatore di task restituito
Interroga lo stato del task o utilizza workflow basati su callback se disponibili
Recupera gli asset video generati al termine

Monitora lo stato dell'attività finché ge

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.

# 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 '
' | 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

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

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);
}

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