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

Sí. Wan 2.6 admite flujos de trabajo de texto a video, imagen a video y referencia a video dentro de la misma familia de modelos.

How long can Wan 2.6 video generations be?

En general, Wan 2.6 admite clips de entre 2 y 15 segundos según el modo.

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

Sí. La generación de audio nativa, las referencias de voz y los flujos de trabajo de sincronización labial sincronizados son características principales.

When should I use Wan 2.6 instead of Wan 2.7?

Elija Wan 2.6 para flujos de trabajo multimodales consolidados y Wan 2.7 para mayor control y planificación.

Can Wan 2.6 maintain character consistency across scenes?

Sí. Los flujos de trabajo basados en referencias preservan la apariencia y la continuidad con mayor fiabilidad que las versiones anteriores.

Is Wan 2.6 suitable for cinematic multi-shot storytelling?

Sí. La generación de múltiples tomas admite flujos narrativos para anuncios y contenido de formato corto.

What are the biggest limitations of Wan 2.6 video generation?

Las principales limitaciones incluyen duraciones cortas, informes de benchmarks escasos y inestabilidad del movimiento ocasional.

Claude Opus 5 is now live on CometAPI →

Wan2.6

Por Segundo:$0.08

Publicado:May 31, 2026

Wan2.6 es un modelo de generación de video diseñado para una síntesis de video estable y eficiente. Ofrece una calidad visual confiable y una generación de movimiento fluida para tareas generales de creación de video.

Nuevo

Uso comercial

Especificaciones técnicas de Wan 2.6

Elemento	Wan 2.6 Video Suite
Proveedor	Alibaba / Tongyi Lab
Familia de modelos	Wan 2.6
Periodo de lanzamiento	Generación de diciembre de 2025
Tipos de entrada	Texto, imágenes, videos de referencia, entradas de audio
Tipo de salida	Video con audio sincronizado opcional
Modos principales	Texto a video (T2V), Imagen a video (I2V), Referencia a video (R2V)
Variantes Flash	I2V Flash, R2V Flash
Compatibilidad de resolución	720P y 1080P
Compatibilidad de duración	2–15 segundos (según el flujo de trabajo)
Capacidades de audio	Generación de audio nativa, referencias de voz, sincronización labial
Compatibilidad con múltiples tomas	2–8 segmentos de escena en un solo flujo de trabajo
Compatibilidad con referencias	Hasta 5 referencias (combinadas de imagen y video según el flujo de trabajo)
Flujo de trabajo de API	Creación de tareas asincrónicas + sondeo

¿Qué es Wan 2.6?

Wan 2.6 es el sistema multimodal de generación de video de Alibaba centrado en la producción controlable de formato corto. En lugar de estar impulsado únicamente por prompts, el modelo combina prompts de texto, referencias de imagen, videos de referencia, condicionamiento de audio y encadenamiento de escenas para flujos de trabajo de creadores. La principal mejora respecto a versiones anteriores de Wan fue la introducción de una mayor consistencia impulsada por referencias y una generación narrativa más larga.

Características principales de Wan 2.6

Flujos de trabajo de referencia a video: Los usuarios pueden proporcionar referencias de imagen o video para mantener la identidad del personaje, el estilo y la continuidad de la voz a través de las generaciones.
Generación narrativa con múltiples tomas: Permite encadenar múltiples prompts para transiciones de escenas y progresión de la historia en un único flujo de generación.
Sincronización de audio nativa: Compatibilidad integrada para audio generado, cargas de audio personalizadas y flujos de trabajo de sincronización labial.
Modos de entrada flexibles: Admite generación solo con prompt, animación del primer fotograma y flujos de trabajo guiados por referencias.
Variantes Flash para iteración: Versiones más rápidas permiten pruebas ágiles antes de los renders finales de alta calidad.
Clips más largos: Duración de clips extendida en comparación con generaciones anteriores, lo que facilita la creación de contenido narrativo.

Rendimiento en benchmarks de Wan 2.6

La transparencia formal en benchmarks para Wan 2.6 sigue siendo limitada; Alibaba ha publicado menos cifras de benchmarks estandarizados que los proveedores de LLM de texto. La mayor parte de la evaluación proviene de pruebas de flujo de trabajo y comparaciones dentro del ecosistema más que de tablas de clasificación públicas. Las pruebas de la comunidad destacan de forma consistente:

Mejor consistencia de personajes frente a versiones anteriores de Wan.
Mejor sincronización de audio y video.
Mayor continuidad entre múltiples tomas.
Condicionamiento por referencias más fiable.

Dado que la publicación de benchmarks es escasa, las pruebas en producción siguen siendo importantes antes de la implementación.

Wan 2.6 frente a otros modelos de video

Característica	Wan 2.6	Wan 2.7	Modelos de la familia Veo
Generación de audio nativa	Fuerte	Más fuerte	Fuerte
Flujo de trabajo con múltiples tomas	Sí	Mejorado	Moderado
Referencia a video	Gran énfasis	Controles más sólidos	Moderado
Duración del clip	Hasta 15 s	Similar / depende del flujo de trabajo	Variable
Compatibilidad con múltiples referencias	Hasta 5 referencias	Flujos de trabajo ampliados	Moderado
Flujos de edición	Moderado	Mejor compatibilidad de edición	Fuerte

Limitaciones de Wan 2.6

La corta duración de los clips aún limita la producción de formato largo.
Las escenas de alto movimiento pueden seguir mostrando inestabilidad temporal.
Los flujos de trabajo con muchas referencias aumentan la complejidad de configuración.
La publicación de benchmarks públicos sigue siendo limitada.
Las canalizaciones de generación asíncrona aumentan la complejidad de integración.

Casos de uso representativos

Videos de marketing con consistencia de personajes.
Clips para redes sociales con múltiples escenas.
Animación de avatares de creadores.
Videos de producto impulsados por referencias.
Narración con IA y audio sincronizado.
Contenido de marca que requiere preservación de la identidad.

Preguntas frecuentes

Precios para Wan2.6

Explora precios competitivos para Wan2.6, diseñado para adaptarse a diversos presupuestos y necesidades de uso. Nuestros planes flexibles garantizan que solo pagues por lo que uses, facilitando el escalado a medida que crecen tus requisitos. Descubre cómo Wan2.6 puede mejorar tus proyectos mientras mantienes los costos manejables.

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 ejemplo y API para Wan2.6

Accede a código de muestra completo y recursos de API para Wan2.6 para agilizar tu proceso de integración. Nuestra documentación detallada proporciona orientación paso a paso, ayudándote a aprovechar todo el potencial de Wan2.6 en tus proyectos.

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

Versiones de Wan2.6

La razón por la cual Wan2.6 tiene múltiples instantáneas puede incluir factores potenciales como variaciones en la salida tras actualizaciones que requieren instantáneas anteriores para mantener la coherencia, ofrecer a los desarrolladores un período de transición para adaptación y migración, y diferentes instantáneas que corresponden a endpoints globales o regionales para optimizar la experiencia del usuario. Para conocer las diferencias detalladas entre versiones, consulte la documentación oficial.

Version
wan2.6