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

Sim. O Wan 2.6 suporta fluxos de trabalho de texto para vídeo, de imagem para vídeo e de referência para vídeo dentro da mesma família de modelos.

How long can Wan 2.6 video generations be?

O Wan 2.6 geralmente suporta clipes entre 2 e 15 segundos, dependendo do modo.

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

Sim. A geração nativa de áudio, as referências de voz e os fluxos de trabalho de sincronização labial são recursos principais.

When should I use Wan 2.6 instead of Wan 2.7?

Escolha o Wan 2.6 para fluxos de trabalho multimodais consolidados e o Wan 2.7 para controle e planejamento mais robustos.

Can Wan 2.6 maintain character consistency across scenes?

Sim. Os fluxos de trabalho com referências preservam a aparência e a continuidade de forma mais confiável do que as versões anteriores.

Is Wan 2.6 suitable for cinematic multi-shot storytelling?

Sim. A geração em múltiplas tomadas oferece suporte a fluxos de trabalho narrativos para anúncios e conteúdos de formato curto.

What are the biggest limitations of Wan 2.6 video generation?

As principais limitações incluem durações curtas, relatórios de benchmark escassos e instabilidade de movimento ocasional.

Claude Opus 5 is now live on CometAPI →

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

Item	Wan 2.6 Video Suite
Fornecedor	Alibaba / Tongyi Lab
Família de modelos	Wan 2.6
Período de lançamento	Geração de dezembro de 2025
Tipos de entrada	Texto, imagens, vídeos de referência, entradas de áudio
Tipo de saída	Vídeo com áudio sincronizado opcional
Modos centrais	Text-to-Video (T2V), Image-to-Video (I2V), Reference-to-Video (R2V)
Variantes Flash	I2V Flash, R2V Flash
Suporte de resolução	720P e 1080P
Suporte de duração	2–15 segundos (dependente do fluxo de trabalho)
Capacidades de áudio	Geração de áudio nativa, referências de voz, sincronização labial
Suporte a múltiplas tomadas	2–8 segmentos de cena em um único fluxo de trabalho
Suporte a referências	Até 5 referências (imagem/vídeo mistos, dependendo do fluxo de trabalho)
Fluxo de trabalho da API	Criaçã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

Recurso	Wan 2.6	Wan 2.7	Modelos da família Veo
Geração de áudio nativa	Forte	Mais forte	Forte
Fluxo de trabalho com múltiplas tomadas	Sim	Aprimorado	Moderado
Referência-para-vídeo	Forte ênfase	Controles mais fortes	Moderado
Duração do clipe	Até 15s	Semelhante / dependente do fluxo de trabalho	Varia
Suporte a múltiplas referências	Até 5 referências	Fluxos de trabalho expandidos	Moderado
Fluxos de edição	Moderado	Melhor suporte a edição	Forte

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

Vídeos de marketing com consistência de personagens.
Clipes para redes sociais com múltiplas cenas.
Animação de avatar de criador.
Vídeos de produto orientados por referências.
Narrativas com IA e áudio sincronizado.
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)

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

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.

POST

/v1/videos

# 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