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.

Przystępne cenowo API Vidu Q3 Turbo | text-to-video

Specyfikacja techniczna Vidu Q3 Turbo

Pozycja	Vidu Q3 Turbo
Model ID	viduq3-turbo
Dostawca	Vidu
Rodzina modeli	Vidu Q3 Series
Typ modelu	Generowanie wideo
Typy wejścia	Tekst, Obraz, Obraz początkowy + obraz końcowy
Typ wyjścia	Wideo z opcjonalnie zsynchronizowanym dźwiękiem
Rozdzielczość	540p, 720p, 1080p
Zakres długości	1–16 sekund
Liczba klatek na sekundę	24 FPS
Generowanie dźwięku	Natywne generowanie audio‑wideo
Tekst na wideo	Obsługiwane
Obraz na wideo	Obsługiwane
Start–end do wideo	Obsługiwane
Referencja do wideo	Obsługiwane za pośrednictwem przepływu pracy Q3 Turbo
Proporcje obrazu	16:9, 9:16, 3:4, 4:3, 1:1
Priorytet	Szybkie, niskoopóźnieniowe generowanie wideo

Czym jest Vidu Q3 Turbo?

Vidu Q3 Turbo to wersja modelu generowania wideo Vidu Q3 zoptymalizowana pod kątem szybkości. Została zaprojektowana dla twórców i deweloperów potrzebujących szybkiej iteracji przy zachowaniu zsynchronizowanego wyjścia audio‑wideo. W przeciwieństwie do wcześniejszych modeli wideo, które wymagały oddzielnych pipeline’ów do produkcji dźwięku, Q3 Turbo potrafi generować dialog, narrację, efekty dźwiękowe, muzykę i wideo razem w jednym przepływie pracy.

Główne funkcje Vidu Q3 Turbo

Natywne generowanie audio‑wideo: Tworzy wideo, dialog, narrację, efekty dźwiękowe i muzykę razem w zsynchronizowanym wyjściu.
Szybki pipeline wnioskowania: Zoptymalizowany pod niższe opóźnienia niż standardowy Vidu Q3 przy zachowaniu spójności wizualnej.
Obsługa generowania 16-sekundowego klipu: Może wygenerować kompletne ujęcia narracyjne do 16 sekund w jednym przebiegu.
Wiele trybów tworzenia: Obsługuje tekst na wideo, obraz na wideo oraz generowanie wideo na podstawie klatek początkowej i końcowej.
Elastyczne rozdzielczości wyjściowe: Obsługuje generowanie w 540p, 720p i 1080p.
Kontrola opowieści na poziomie klatki: Obsługuje szczegółowe instrukcje dotyczące ruchu kamery i tempa dla filmowych rezultatów.

Wydajność w benchmarkach Vidu Q3 Turbo

Vidu nie opublikowało publicznie ustandaryzowanych wyników benchmarków porównywalnych z benchmarkami modeli językowych AI, takimi jak MMLU czy SWE-Bench. Zamiast tego Vidu pozycjonuje Q3 Turbo w oparciu o metryki produkcyjne:

Możliwość	Podane publicznie
Czas trwania pojedynczej generacji	Do 16 sekund
Rozdzielczość	Do 1080p
Obsługa natywnego audio	Tak
Dialog wielogłosowy	Obsługiwane
Wielojęzyczne generowanie wideo	angielski, japoński, chiński

Ponieważ nie opublikowano oficjalnego rankingu benchmarków dla Q3 Turbo, niezależne porównania benchmarkowe są obecnie niedostępne.

Vidu Q3 Turbo vs Vidu Q3 vs Kling 2.1

Funkcja	Vidu Q3 Turbo	Vidu Q3	Kling 2.1
Szybkość generowania	Najszybszy w rodzinie Q3	Nacisk na wyższą jakość	Konkurencyjne
Natywne audio	Tak	Tak	Ograniczone w zależności od przepływu pracy
Maks. długość	16s	16s	Różnie
Rozdzielczość	Do 1080p	Do 1080p	Do 1080p
Tekst na wideo	Tak	Tak	Tak
Obraz na wideo	Tak	Tak	Tak
Najlepsze do	Szybka iteracja	Wysokiej jakości narracja	Filmowe generowanie

Znane ograniczenia

Maksymalna długość klipu to 16 sekund na jedną generację.
Produkcje długometrażowe wymagają łączenia wielu klipów.
Obecnie brak publicznie dostępnego ustandaryzowanego zestawu benchmarków.
Jakość może być nieznacznie niższa niż w wariantach nastawionych na jakość premium, gdy priorytetem jest maksymalna szybkość generowania.

Przykładowe zastosowania

Produkcja krótkich dramatów

Generuj kompletne sceny narracyjne ze zsynchronizowaną mową, efektami dźwiękowymi i muzyką.

Treści do mediów społecznościowych

Szybko twórz materiały na TikTok, Reels, Shorts oraz reklamy przy minimalnej postprodukcji.

Tworzenie storyboardów i prewizualizacja

Konwertuj scenariusze lub concept art na animowane sekwencje do przeglądu kreatywnego.

Wideo marketingowe

Twórz prezentacje produktów, klipy promocyjne i materiały storytellingowe dla marek.

Animacja postaci

Animuj obrazy referencyjne, zachowując spójność wizualną między scenami.

Informacje o wersji modelu

Vidu Q3 Turbo należy do generacji modeli Q3 i jest pozycjonowany jako alternatywa o niższych opóźnieniach względem standardowego Q3. Model kładzie nacisk na szybkość produkcji, zsynchronizowane generowanie audio oraz przepływy pracy ukierunkowane na storytelling twórców, jednocześnie zachowując obsługę wyjścia wideo 1080p i generowanie 16‑sekundowych klipów.

Jak uzyskać dostęp i wdrożyć API viduq3 Turbo na CometAPI

Krok 1: Zarejestruj się lub zaloguj do CometAPI i uzyskaj klucz API viduq3 Turbo

Utwórz konto CometAPI lub zaloguj się na istniejące, aby uzyskać dostęp do API po jego udostępnieniu (API viduq3 Turbo). Po wydaniu będziesz mógł uzyskać klucz API HappyHorse-1.0 z platformy i rozpocząć testy lub integrację.

Krok 2: Przetestuj bezpłatnie API viduq3 Turbo w Playground

Przed wdrożeniem możesz wypróbować API viduq3 bezpośrednio w Playground CometAPI. To prosty sposób, aby zbadać jakość wyjścia, przetestować prompty lub wejścia obrazowe i lepiej zrozumieć wydajność API viduq3 Turbo przed użyciem w produkcji.

Krok 3: Wdroż API viduq3 w produkcji

Po testach kolejnym krokiem jest wdrożenie API viduq3 do Twojej aplikacji, produktu lub środowiska wewnętrznego. Umożliwi to wykorzystanie API viduq3 w rzeczywistych scenariuszach generowania wideo, gdzie kluczowe są stabilny dostęp i praktyczna integracja.

Cennik dla Vidu Q3 Turbo

Poznaj konkurencyjne ceny dla Vidu Q3 Turbo, zaprojektowane tak, aby pasowały do różnych budżetów i potrzeb użytkowania. Nasze elastyczne plany zapewniają, że płacisz tylko za to, czego używasz, co ułatwia skalowanie w miarę wzrostu Twoich wymagań. Odkryj, jak Vidu Q3 Turbo może ulepszyć Twoje projekty przy jednoczesnym utrzymaniu kosztów na rozsądnym poziomie.

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

Przykładowy kod i API dla Vidu Q3 Turbo

Uzyskaj dostęp do kompleksowego przykładowego kodu i zasobów API dla Vidu Q3 Turbo, aby usprawnić proces integracji. Nasza szczegółowa dokumentacja zapewnia wskazówki krok po kroku, pomagając wykorzystać pełny potencjał Vidu Q3 Turbo w Twoich projektach.

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

Wersje modelu Vidu Q3 Turbo

Powody, dla których Vidu Q3 Turbo posiada wiele migawek, mogą obejmować takie czynniki jak: różnice w wynikach po aktualizacjach wymagające starszych migawek dla zachowania spójności, zapewnienie programistom okresu przejściowego na adaptację i migrację, oraz różne migawki odpowiadające globalnym lub regionalnym punktom końcowym w celu optymalizacji doświadczenia użytkownika. Aby poznać szczegółowe różnice między wersjami, zapoznaj się z oficjalną dokumentacją.

version
viduq3-turbo

Vidu Q3 Turbo