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.

Erschwingliche Vidu Q3 Turbo API | text-to-video

Technische Spezifikationen von Vidu Q3 Turbo

Element	Vidu Q3 Turbo
Modell-ID	viduq3-turbo
Anbieter	Vidu
Modellfamilie	Vidu Q3 Series
Modelltyp	Videoerzeugung
Eingabetypen	Text, Bild, Startbild + Endbild
Ausgabetyp	Video mit optional synchronisiertem Audio
Auflösung	540p, 720p, 1080p
Dauerbereich	1–16 Sekunden
Bildrate	24 FPS
Audiogenerierung	Native Audio-Video-Generierung
Text-zu-Video	Unterstützt
Bild-zu-Video	Unterstützt
Start-Ende-zu-Video	Unterstützt
Referenz-zu-Video	Unterstützt über Q3 Turbo-Workflow
Seitenverhältnisse	16:9, 9:16, 3:4, 4:3, 1:1
Primärer Fokus	Schnelle Videogenerierung mit geringer Latenz

Was ist Vidu Q3 Turbo?

Vidu Q3 Turbo ist die geschwindigkeitsoptimierte Version des Vidu Q3 Videogenerierungsmodells. Es ist für Kreative und Entwickler konzipiert, die schnelle Iterationen benötigen und gleichzeitig eine synchronisierte Audio-Video-Ausgabe beibehalten möchten. Anders als frühere Videomodelle, die separate Audioproduktions-Pipelines erforderten, kann Q3 Turbo Dialog, Erzählung, Soundeffekte, Musik und Video gemeinsam in einem einzigen Generierungs-Workflow erzeugen.

Hauptfunktionen von Vidu Q3 Turbo

Native Audio-Video-Generierung: Erzeugt Video, Dialog, Erzählung, Soundeffekte und Musik gemeinsam in einer synchronisierten Ausgabe.
Schnelle Inferenz-Pipeline: Für geringere Latenz als das standardmäßige Vidu Q3 optimiert, bei Erhalt der visuellen Konsistenz.
Unterstützung für 16-sekündige Generierung: Kann vollständige narrative Clips bis zu 16 Sekunden in einem Durchlauf erzeugen.
Mehrere Erstellungsmodi: Unterstützt Text-zu-Video, Bild-zu-Video und Start-/End-Frame-Videogenerierung.
Flexible Ausgabeauflösungen: Unterstützt 540p, 720p und 1080p.
Erzählsteuerung auf Frame-Ebene: Unterstützt detaillierte Kamerabewegungen und Tempovorgaben für kinematografische Ausgaben.

Benchmark-Leistung von Vidu Q3 Turbo

Vidu hat keine standardisierten Benchmark-Werte veröffentlicht, die mit KI-Sprachmodell-Benchmarks wie MMLU oder SWE-Bench vergleichbar wären. Stattdessen positioniert Vidu Q3 Turbo anhand von Produktionskennzahlen:

Fähigkeit	Öffentlich berichtet
Dauer einer einzelnen Generierung	Bis zu 16 Sekunden
Auflösung	Bis zu 1080p
Native Audio-Unterstützung	Ja
Dialoge mit mehreren Sprechern	Unterstützt
Mehrsprachige Videogenerierung	Englisch, Japanisch, Chinesisch

Da keine offizielle Benchmark-Bestenliste für Q3 Turbo veröffentlicht wurde, sind unabhängige Benchmark-Vergleiche derzeit nicht verfügbar.

Vidu Q3 Turbo vs Vidu Q3 vs Kling 2.1

Funktion	Vidu Q3 Turbo	Vidu Q3	Kling 2.1
Generierungsgeschwindigkeit	Am schnellsten in der Q3-Familie	Fokus auf höhere Qualität	Wettbewerbsfähig
Natives Audio	Ja	Ja	Begrenzt, abhängig vom Workflow
Maximale Dauer	16 s	16 s	Variiert
Auflösung	Bis zu 1080p	Bis zu 1080p	Bis zu 1080p
Text-zu-Video	Ja	Ja	Ja
Bild-zu-Video	Ja	Ja	Ja
Am besten geeignet für	Schnelle Iterationen	Premium-Erzählqualität	Kinematografische Generierung

Bekannte Einschränkungen

Maximale Clip-Länge beträgt 16 Sekunden pro Generierung.
Langform-Produktionen erfordern das Aneinanderreihen mehrerer Clips.
Derzeit ist keine öffentlich verfügbare standardisierte Benchmark-Suite vorhanden.
Die Qualität kann etwas niedriger ausfallen als bei auf Premium fokussierten Varianten, wenn die maximale Generierungsgeschwindigkeit priorisiert wird.

Repräsentative Anwendungsfälle

Produktion kurzer Dramen

Vollständige Erzählszenen mit synchronisierter Sprache, Soundeffekten und Musik erzeugen.

TikTok-, Reels-, Shorts- und Werbevideos mit minimaler Postproduktion schnell erstellen.

Storyboard-Erstellung und Previsualisierung

Drehbücher oder Konzeptkunst in animierte Sequenzen für die kreative Überprüfung umwandeln.

Marketingvideos

Produktpräsentationen, Promo-Clips und markengerechte Storytelling-Inhalte produzieren.

Charakteranimation

Referenzbilder animieren und dabei visuelle Konsistenz über Szenen hinweg bewahren.

Hinweise zur Modellversion

Vidu Q3 Turbo gehört zur Q3-Generation der Vidu-Modelle und ist als latenzärmere Alternative zum Standard-Q3 positioniert. Das Modell legt den Schwerpunkt auf Produktionsgeschwindigkeit, synchronisierte Audiogenerierung und erzählerische Workflows für Kreative, bei gleichzeitiger Unterstützung von 1080p-Videoausgabe und 16-sekündiger Clip-Erzeugung.

Zugriff und Bereitstellung der viduq3 Turbo API auf CometAPI

Schritt 1: Registrieren oder anmelden bei CometAPI und Ihren viduq3 Turbo API-Schlüssel erhalten

Erstellen Sie Ihr CometAPI-Konto oder melden Sie sich bei einem bestehenden Konto an, um auf die API zuzugreifen, sobald sie verfügbar ist (viduq3 Turbo API). Nach der Veröffentlichung können Sie einen HappyHorse-1.0-API-Schlüssel von der Plattform erhalten und sind bereit für Tests oder die Integration.

Schritt 2: Testen Sie die viduq3 Turbo API kostenlos im Playground

Vor der Bereitstellung können Sie die viduq3 API direkt im CometAPI-Playground ausprobieren. So können Sie die Ausgabequalität erkunden, Prompts oder Bildeingaben testen und sich vor dem Einsatz in der Produktion ein klareres Bild von der Leistung der viduq3 Turbo API verschaffen.

Schritt 3: Setzen Sie die viduq3 API in der Produktion ein

Nach den Tests besteht der nächste Schritt darin, die viduq3 API in Ihrer eigenen Anwendung, Ihrem Produkt oder Ihrer internen Umgebung bereitzustellen. So können Sie die viduq3 API in realen Videogenerierungsszenarien nutzen, in denen stabiler Zugriff und praktische Integration entscheidend sind.

Preise für Vidu Q3 Turbo

Entdecken Sie wettbewerbsfähige Preise für Vidu Q3 Turbo, die für verschiedene Budgets und Nutzungsanforderungen konzipiert sind. Unsere flexiblen Tarife stellen sicher, dass Sie nur für das bezahlen, was Sie nutzen, und erleichtern die Skalierung entsprechend Ihren wachsenden Anforderungen. Erfahren Sie, wie Vidu Q3 Turbo Ihre Projekte verbessern kann, während die Kosten überschaubar bleiben.

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

Beispielcode und API für Vidu Q3 Turbo

Greifen Sie auf umfassende Beispielcodes und API-Ressourcen für Vidu Q3 Turbo zu, um Ihren Integrationsprozess zu optimieren. Unsere detaillierte Dokumentation bietet schrittweise Anleitungen und hilft Ihnen dabei, das volle Potenzial von Vidu Q3 Turbo in Ihren Projekten zu nutzen.

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

Versionen von Vidu Q3 Turbo

Der Grund, warum Vidu Q3 Turbo mehrere Snapshots hat, kann potenzielle Faktoren wie Änderungen der Ausgabe nach Updates umfassen, die ältere Snapshots für Konsistenz erfordern, Entwicklern eine Übergangszeit für Anpassung und Migration bieten und verschiedene Snapshots, die globalen oder regionalen Endpunkten entsprechen, um das Benutzererlebnis zu optimieren. Für detaillierte Unterschiede zwischen den Versionen lesen Sie bitte die offizielle Dokumentation.

version
viduq3-turbo

Vidu Q3 Turbo