Claude Opus 5 is now live on CometAPI →
Q

Wan2.6

Por Segundo:$0.08
Lançado:May 31, 2026

Wan2.6 é um modelo de geração de vídeo projetado para síntese de vídeo estável e eficiente. Ele fornece qualidade visual confiável e geração de movimento suave para tarefas gerais de criação de vídeo.

Novo
Uso comercial

Especificações Técnicas do Wan 2.6

ItemWan 2.6 Video Suite
FornecedorAlibaba / Tongyi Lab
Família de modelosWan 2.6
Período de lançamentoGeração de dezembro de 2025
Tipos de entradaTexto, imagens, vídeos de referência, entradas de áudio
Tipo de saídaVídeo com áudio sincronizado opcional
Modos centraisText-to-Video (T2V), Image-to-Video (I2V), Reference-to-Video (R2V)
Variantes FlashI2V Flash, R2V Flash
Suporte de resolução720P e 1080P
Suporte de duração2–15 segundos (dependente do fluxo de trabalho)
Capacidades de áudioGeração de áudio nativa, referências de voz, sincronização labial
Suporte a múltiplas tomadas2–8 segmentos de cena em um único fluxo de trabalho
Suporte a referênciasAté 5 referências (imagem/vídeo mistos, dependendo do fluxo de trabalho)
Fluxo de trabalho da APICriação assíncrona de tarefas + polling

O que é o Wan 2.6?

O Wan 2.6 é o sistema multimodal de geração de vídeo da Alibaba, focado em produção de formatos curtos controláveis. Em vez de ser orientado apenas por prompts, o modelo combina prompts de texto, referências de imagem, vídeos de referência, condicionamento de áudio e encadeamento de cenas para fluxos de trabalho de criadores. A grande atualização em relação às versões anteriores do Wan foi a introdução de uma consistência orientada por referências mais robusta e geração narrativa mais longa.

Principais recursos do Wan 2.6

  • Fluxos de trabalho de referência para vídeo: Usuários podem fornecer referências de imagem ou vídeo para manter a identidade de personagens, o estilo e a continuidade de voz ao longo das gerações.
  • Geração narrativa com múltiplas tomadas: Suporta encadear vários prompts para transições de cena e progressão da história em um único fluxo de geração.
  • Sincronização de áudio nativa: Suporte integrado para áudio gerado, upload de áudio personalizado e fluxos de trabalho de sincronização labial.
  • Modos de entrada flexíveis: Suporta geração apenas por prompt, animação a partir do primeiro quadro e fluxos de trabalho orientados por referências.
  • Variantes Flash para iteração: Versões mais rápidas permitem testes rápidos antes dos renders finais de alta qualidade.
  • Clipes mais longos: Duração de clipes estendida em comparação com gerações anteriores, suportando a criação de conteúdo narrativo.

Desempenho em benchmarks do Wan 2.6

A transparência formal de benchmarks para o Wan 2.6 permanece limitada; a Alibaba publicou menos números padronizados de benchmark do que provedores de LLMs de texto. A maior parte da avaliação vem de testes de fluxo de trabalho e comparações no ecossistema, em vez de rankings públicos. Testes da comunidade destacam consistentemente:

  • Maior consistência de personagens em relação às versões anteriores do Wan.
  • Melhor sincronização áudio-vídeo.
  • Continuidade mais robusta em múltiplas tomadas.
  • Condicionamento por referência mais confiável.

Como a publicação de benchmarks é escassa, os testes em produção continuam importantes antes da implantação.

Wan 2.6 vs Outros Modelos de Vídeo

RecursoWan 2.6Wan 2.7Modelos da família Veo
Geração de áudio nativaForteMais forteForte
Fluxo de trabalho com múltiplas tomadasSimAprimoradoModerado
Referência-para-vídeoForte ênfaseControles mais fortesModerado
Duração do clipeAté 15sSemelhante / dependente do fluxo de trabalhoVaria
Suporte a múltiplas referênciasAté 5 referênciasFluxos de trabalho expandidosModerado
Fluxos de ediçãoModeradoMelhor suporte a ediçãoForte

Limitações do Wan 2.6

  • A duração curta dos clipes ainda limita a produção de formato longo.
  • Cenas com muito movimento podem apresentar instabilidade temporal.
  • Fluxos de trabalho muito dependentes de referências aumentam a complexidade de configuração.
  • A divulgação pública de benchmarks permanece limitada.
  • Pipelines assíncronos de geração aumentam a complexidade de integração.

Casos de uso representativos

  1. Vídeos de marketing com consistência de personagens.
  2. Clipes para redes sociais com múltiplas cenas.
  3. Animação de avatar de criador.
  4. Vídeos de produto orientados por referências.
  5. Narrativas com IA e áudio sincronizado.
  6. Conteúdo de marca que exige preservação de identidade.

FAQ

Preços para Wan2.6

Explore preços competitivos para Wan2.6, projetado para atender diversos orçamentos e necessidades de uso. Nossos planos flexíveis garantem que você pague apenas pelo que usar, facilitando o dimensionamento conforme suas necessidades crescem. Descubra como Wan2.6 pode aprimorar seus projetos mantendo os custos gerenciáveis.

Wan Video Generation Pricing

Pricing (Per Second)

Model720p1080p
wan2.6$0.08$0.12
wan2.7$0.08$0.12

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

Código de exemplo e API para Wan2.6

Acesse código de exemplo abrangente e recursos de API para Wan2.6 para otimizar seu processo de integração. Nossa documentação detalhada fornece orientação passo a passo, ajudando você a aproveitar todo o potencial do Wan2.6 em seus projetos.

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

Versões do Wan2.6

O motivo pelo qual Wan2.6 possui múltiplas versões instantâneas pode incluir fatores como variações na saída após atualizações que exigem versões antigas para consistência, fornecendo aos desenvolvedores um período de transição para adaptação e migração, e diferentes versões correspondentes a endpoints globais ou regionais para otimizar a experiência do usuário. Para diferenças detalhadas entre versões, consulte a documentação oficial.

Version
wan2.6