Can Wan 2.6 API generate videos from text, images, and references?

Sì. Wan 2.6 supporta i flussi di lavoro text-to-video, image-to-video e reference-to-video all'interno della stessa famiglia di modelli.

How long can Wan 2.6 video generations be?

In genere, Wan 2.6 supporta clip tra 2 e 15 secondi, a seconda della modalità.

Does Wan 2.6 API support native audio generation and lip sync?

Sì. La generazione audio nativa, i riferimenti vocali e i flussi di lavoro di lip-sync sincronizzati sono funzionalità principali.

When should I use Wan 2.6 instead of Wan 2.7?

Scegli Wan 2.6 per flussi di lavoro multimodali consolidati e Wan 2.7 per una maggiore controllabilità e pianificazione.

Can Wan 2.6 maintain character consistency across scenes?

Sì. I flussi di lavoro basati su riferimenti preservano l'aspetto e la continuità in modo più affidabile rispetto alle versioni precedenti.

Is Wan 2.6 suitable for cinematic multi-shot storytelling?

Sì. La generazione multi-shot supporta flussi di lavoro narrativi per annunci e contenuti di breve durata.

What are the biggest limitations of Wan 2.6 video generation?

Le principali limitazioni includono durate brevi, reportistica di benchmark limitata e instabilità del movimento occasionali.

API Wan2.6 Conveniente | image-to-video

Specifiche tecniche di Wan 2.6

Voce	Suite video Wan 2.6
Fornitore	Alibaba / Tongyi Lab
Famiglia di modelli	Wan 2.6
Periodo di rilascio	Generazione di dicembre 2025
Tipi di input	Testo, immagini, video di riferimento, input audio
Tipo di output	Video con audio sincronizzato opzionale
Modalità principali	Da testo a video (T2V), Da immagine a video (I2V), Da riferimento a video (R2V)
Varianti Flash	I2V Flash, R2V Flash
Supporto di risoluzione	720P e 1080P
Durata supportata	2–15 secondi (in base al workflow)
Capacità audio	Generazione audio nativa, riferimenti vocali, sincronizzazione labiale
Supporto multi-shot	2–8 segmenti di scena in un singolo workflow
Supporto ai riferimenti	Fino a 5 riferimenti (immagine/video misti a seconda del workflow)
Workflow API	Creazione di attività asincrone + polling

Che cos’è Wan 2.6?

Wan 2.6 è il sistema multimodale di generazione video di Alibaba, focalizzato su produzioni di breve durata controllabili. Piuttosto che essere guidato esclusivamente dai prompt, il modello combina prompt testuali, riferimenti di immagini, video di riferimento, condizionamento audio e concatenazione delle scene per i workflow dei creatori. Il principale aggiornamento rispetto alle versioni precedenti di Wan è stata l’introduzione di una coerenza più forte guidata dai riferimenti e di una generazione narrativa più lunga.

Caratteristiche principali di Wan 2.6

Workflow da riferimento a video: gli utenti possono fornire riferimenti di immagini o video per mantenere l’identità dei personaggi, lo stile e la continuità della voce tra le generazioni.
Generazione narrativa multi-shot: consente di concatenare più prompt per transizioni di scena e progressione della storia in un singolo workflow di generazione.
Sincronizzazione audio nativa: supporto integrato per audio generato, caricamenti audio personalizzati e workflow di sincronizzazione labiale.
Modalità di input flessibili: supporta generazione basata solo su prompt, animazione del primo fotogramma e workflow guidati da riferimenti.
Varianti Flash per l’iterazione: versioni più veloci consentono test rapidi prima dei render finali di alta qualità.
Clip più lunghe: durata delle clip estesa rispetto alle generazioni precedenti, a supporto della creazione di contenuti narrativi.

Prestazioni nei benchmark di Wan 2.6

La trasparenza formale dei benchmark per Wan 2.6 rimane limitata; Alibaba ha pubblicato meno numeri di benchmark standardizzati rispetto ai provider di LLM testuali. La maggior parte delle valutazioni deriva da test dei workflow e confronti nell’ecosistema, più che da classifiche pubbliche. I test della community evidenziano costantemente:

Maggiore coerenza dei personaggi rispetto alle versioni precedenti di Wan.
Migliore sincronizzazione audio-video.
Maggiore continuità multi-shot.
Condizionamento sui riferimenti più affidabile.

Poiché la pubblicazione di benchmark è scarsa, i test in produzione restano importanti prima della messa in produzione.

Wan 2.6 vs altri modelli video

Funzionalità	Wan 2.6	Wan 2.7	Modelli della famiglia Veo
Generazione audio nativa	Forte	Più forte	Forte
Workflow multi-shot	Sì	Migliorato	Moderato
Da riferimento a video	Forte enfasi	Controlli più avanzati	Moderato
Durata clip	Fino a 15s	Simile / dipende dal workflow	Variabile
Supporto multi-riferimento	Fino a 5 riferimenti	Workflow ampliati	Moderato
Workflow di editing	Moderato	Supporto di editing migliore	Forte

Limitazioni di Wan 2.6

La breve durata delle clip limita ancora la produzione di contenuti di lungo formato.
Le scene con movimenti intensi possono ancora mostrare instabilità temporale.
I workflow fortemente basati sui riferimenti aumentano la complessità di configurazione.
La pubblicazione di benchmark pubblici rimane limitata.
Le pipeline di generazione asincrone aumentano la complessità di integrazione.

Casi d’uso rappresentativi

Video marketing con coerenza dei personaggi.
Clip multi-scena per social media.
Animazione di avatar dei creatori.
Video di prodotto guidati da riferimenti.
Storytelling AI con audio sincronizzato.
Contenuti di brand che richiedono la preservazione dell’identità.

Prezzi per Wan2.6

Esplora i prezzi competitivi per Wan2.6, 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 Wan2.6 può migliorare i tuoi progetti mantenendo i costi gestibili.

Wan Video Generation Pricing

Pricing (Per Second)

Model	720p	1080p
`wan2.6`	$0.08	$0.12
`wan2.7`	$0.08	$0.12

💡 Billed per second. Total cost = price per second × video duration (seconds).

Codice di esempio e API per Wan2.6

Accedi a codice di esempio completo e risorse API per Wan2.6 per semplificare il tuo processo di integrazione. La nostra documentazione dettagliata fornisce una guida passo dopo passo, aiutandoti a sfruttare appieno il potenziale di Wan2.6 nei tuoi progetti.

# Create a video with wan2.6
# 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=wan2.6" \
  -F "prompt=Create a cinematic multi-shot chase across a moonlit desert market. Shot 1 [0-2s]: a wide establishing view of lanterns and dust in the air. Shot 2 [2-4s]: a small brass robot darts between fabric stalls. Shot 3 [4-5s]: close-up on the robot finding a glowing compass." \
  -F "seconds=5" \
  -F "size=1280x720")

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 wan2.6
# 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=wan2.6" \
  -F "prompt=Create a cinematic multi-shot chase across a moonlit desert market. Shot 1 [0-2s]: a wide establishing view of lanterns and dust in the air. Shot 2 [2-4s]: a small brass robot darts between fabric stalls. Shot 3 [4-5s]: close-up on the robot finding a glowing compass." \
  -F "seconds=5" \
  -F "size=1280x720")

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 wan2.6 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, "wan2.6"),
        "prompt": (None, "Create a cinematic multi-shot chase across a moonlit desert market. Shot 1 [0-2s]: a wide establishing view of lanterns and dust in the air. Shot 2 [2-4s]: a small brass robot darts between fabric stalls. Shot 3 [4-5s]: close-up on the robot finding a glowing compass."),
        "seconds": (None, "5"),
        "size": (None, "1280x720"),
    },
)

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 wan2.6 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", "wan2.6");
formData.append("prompt", "Create a cinematic multi-shot chase across a moonlit desert market. Shot 1 [0-2s]: a wide establishing view of lanterns and dust in the air. Shot 2 [2-4s]: a small brass robot darts between fabric stalls. Shot 3 [4-5s]: close-up on the robot finding a glowing compass.");
formData.append("seconds", "5");
formData.append("size", "1280x720");

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 Wan2.6

Il motivo per cui Wan2.6 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
wan2.6

Wan2.6