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

Tak. Vidu Q3 Turbo obsługuje natywne generowanie audio-wideo, umożliwiając tworzenie dialogów, narracji, efektów dźwiękowych, muzyki i warstwy wizualnej jednocześnie w zsynchronizowanym materiale wyjściowym.

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

Vidu Q3 Turbo obsługuje długości wideo od 1 do 16 sekund na jedno generowanie, w zależności od wybranego przepływu pracy i ustawień.

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

Wybierz Vidu Q3 Turbo, gdy priorytetem są szybkość generowania i szybka iteracja. Standardowy Vidu Q3 jest zasadniczo ukierunkowany na wyższej jakości materiały narracyjne, w których opóźnienie ma mniejsze znaczenie.

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

Tak. Model obsługuje przepływy pracy typu image-to-video, umożliwiając animowanie statycznych obrazów w klipy wideo przy zachowaniu spójności wizualnej.

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

Tak. API obsługuje wiele proporcji obrazu, w tym 9:16, co czyni je odpowiednim dla TikTok, YouTube Shorts i Instagram Reels.

What output resolutions are available in Vidu Q3 Turbo?

Vidu Q3 Turbo obsługuje generowanie wideo w rozdzielczościach 540p, 720p i 1080p przy 24 FPS.

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

Model jest zoptymalizowany pod kątem krótkich form i obecnie ogranicza pojedynczy klip do 16 sekund. Dłuższe produkcje wymagają łączenia wielu wygenerowanych scen na etapie montażu.

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

Specyfikacja techniczna Vidu Q3 Turbo

Parametr	Vidu Q3 Turbo
Identyfikator modelu	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 czasu trwania	1–16 sekund
Liczba klatek na sekundę	24 FPS
Generowanie dźwięku	Natywne generowanie audio-wideo
Tekst do wideo	Obsługiwane
Obraz do wideo	Obsługiwane
Początek–koniec do wideo	Obsługiwane
Referencja do wideo	Obsługiwane poprzez przepływ pracy Q3 Turbo
Proporcje obrazu	16:9, 9:16, 3:4, 4:3, 1:1
Główny nacisk	Szybkie generowanie wideo o niskich opóźnieniach

Czym jest Vidu Q3 Turbo?

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

Główne funkcje Vidu Q3 Turbo

Natywne generowanie audio-wideo: Wytwarza wideo, dialog, narrację, efekty dźwiękowe i muzykę razem w zsynchronizowanym wyjściu.
Szybki potok inferencji: Zoptymalizowany pod kątem niższych opóźnień niż standardowy Vidu Q3 przy zachowaniu spójności wizualnej.
Obsługa 16-sekundowej generacji: Może generować kompletne klipy narracyjne do 16 sekund w jednym przebiegu.
Wiele trybów tworzenia: Obsługuje tekst do wideo, obraz do wideo oraz generowanie wideo z klatką początkową i końcową.
Elastyczne rozdzielczości wyjściowe: Obsługuje generowanie 540p, 720p i 1080p.
Kontrola narracji na poziomie klatek: Obsługuje szczegółowe instrukcje ruchu kamery i tempa dla filmowych rezultatów.

Wydajność w benchmarkach Vidu Q3 Turbo

Vidu nie opublikował publicznie zestandaryzowanych 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ść	Publicznie raportowane
Czas trwania pojedynczej generacji	Do 16 sekund
Rozdzielczość	Do 1080p
Natywna obsługa audio	Tak
Dialog wielu mówców	Obsługiwane
Wielojęzyczne generowanie wideo	angielski, japoński, chiński

Ponieważ nie opublikowano oficjalnej tabeli wyników 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
Prędkość generacji	Najszybszy w rodzinie Q3	Nastawienie na wyższą jakość	Konkurencyjna
Natywne audio	Tak	Tak	Ograniczone w zależności od przepływu pracy
Maks. czas trwania	16 s	16 s	Różny
Rozdzielczość	Do 1080p	Do 1080p	Do 1080p
Tekst do wideo	Tak	Tak	Tak
Obraz do wideo	Tak	Tak	Tak
Najlepszy do	Szybkie iteracje	Narracje klasy premium	Filmowe generowanie

Znane ograniczenia

Maksymalna długość klipu wynosi 16 sekund na generację.
Produkcje długometrażowe wymagają łączenia wielu klipów.
Obecnie nie istnieje publicznie dostępny zestandaryzowany zestaw benchmarków.
Jakość może być nieco niższa niż w wariantach nastawionych na jakość, gdy priorytetem jest maksymalna szybkość generacji.

Reprezentatywne przypadki użycia

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 filmy na TikTok, Reels, Shorts oraz materiały reklamowe przy minimalnej postprodukcji.

Storyboarding i prewizualizacja

Przekształcaj scenariusze lub concept art w sekwencje animowane do przeglądu kreatywnego.

Filmy marketingowe

Produkuj prezentacje produktów, klipy promocyjne i brandowane treści narracyjne.

Animacja postaci

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

Informacje o wersji modelu

Vidu Q3 Turbo należy do generacji Q3 modeli Vidu i jest pozycjonowany jako alternatywa o niższej latencji względem standardowego Q3. Model kładzie nacisk na szybkość produkcyjną, zsynchronizowaną generację audio oraz ukierunkowane na twórców przepływy narracyjne, zachowując obsługę wyjścia wideo 1080p i generacji 16-sekundowych klipów.

Jak korzystać z Vidu Q3 Turbo na CometAPI

Podczas korzystania z Vidu Q3 Turbo poprzez CometAPI, aplikacje zazwyczaj wysyłają żądanie generacji wideo, otrzymują identyfikator zadania, monitorują status zadania asynchronicznie i pobierają gotowe zasoby po zakończeniu generacji.

Ten przepływ pracy dobrze sprawdza się w systemach produkcyjnych, platformach treści i zautomatyzowanych potokach medialnych.

Przepływ pracy

Uwierzytelnij się w CometAPI
Wyślij żądanie generacji Vidu Q3 Turbo
Zachowaj zwrócony identyfikator zadania
Odpytuj status zadania lub użyj przepływów opartych na wywołaniach zwrotnych, jeśli dostępne
Pobierz wygenerowane zasoby wideo po zakończeniu

Monitoruj status zadania aż do ge

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