Claude Opus 5 is now live on CometAPI →
Q

Wan2.7

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

Wan2.7 é um modelo de geração de vídeo projetado para síntese visual de alta qualidade e consistência de movimento aprimorada. É adequado para criação de conteúdo cinematográfico e fluxos de trabalho profissionais de produção de vídeo.

Novo
Uso comercial

Especificações técnicas do Wan 2.7

ItemWan 2.7 (Video Suite)
FornecedorAlibaba Tongyi Lab
Família do modeloWan 2.7 Video Suite
ArquiteturaMistura de Especialistas (MoE) com 27B parâmetros
Tipos de entradaTexto, imagens, vídeos, referências de áudio
Tipos de saídaClipes de vídeo gerados/editados com áudio opcional
Modos suportadosTexto para vídeo (T2V), Imagem para vídeo (I2V), Referência para vídeo (R2V), Edição de vídeo
ResoluçãoSaídas em 720P e 1080P
Duração do vídeo2–15 segundos
Suporte a áudioGeração de áudio nativa, referências de voz, fluxos de trabalho de sincronização labial
Capacidade de referênciaMúltiplas imagens/vídeos de referência, consistência de identidade
Consistência de personagemSuporta até vários sujeitos de referência, dependendo do fluxo de trabalho
Geração de lançamentoSucessora principal do Wan 2.6

O que é o Wan 2.7?

Wan 2.7 é a suíte multimodal de geração de vídeo carro-chefe da Alibaba, criada para fluxos de trabalho controláveis de produção cinematográfica por IA, em vez da simples criação de vídeo a partir de prompts. A família de modelos combina geração, edição, continuação e consistência orientada por referências em um único sistema, permitindo que criadores desenvolvam clipes cinematográficos curtos com maior preservação do sujeito e controle de cena.

Ao contrário de geradores de vídeo anteriores que se concentravam principalmente na qualidade do prompt, o Wan 2.7 enfatiza a controlabilidade por meio de ancoragem de quadros, entradas de referência, sincronização de áudio e fluxos de trabalho estruturados de múltiplas tomadas.

Principais recursos do Wan 2.7

  • Pipeline de planejamento Thinking Mode: O modelo planeja a composição da cena e o movimento antes da renderização, melhorando a aderência ao prompt e reduzindo falhas de coerência.
  • Controle de primeiro e último quadro: Os usuários podem definir quadros de abertura e de encerramento para que o sistema interpole o movimento entre eles.
  • Consistência de identidade orientada por referências: Mantém a aparência do personagem, vestuário, objetos e estilo em múltiplas tomadas.
  • Fluxos de trabalho multimodais nativos: Suporta referências de texto, imagem, áudio e vídeo no mesmo fluxo de trabalho.
  • Geração de áudio integrada: Música de fundo, sons ambientes e sincronização de voz podem ser gerados junto aos visuais.
  • Suporte a edição e continuação: Vídeos existentes podem ser estendidos, transformados ou reestilizados sem reconstruir do zero.

Desempenho em benchmarks do Wan 2.7

A divulgação pública de benchmarks do Wan 2.7 permanece limitada em comparação com LLMs de texto, mas avaliações de terceiros e testes da comunidade indicam melhorias notáveis em estabilidade de movimento, aderência ao prompt e controlabilidade em relação ao Wan 2.6.

Observações relatadas no ecossistema incluem:

  • Maior continuidade de movimento em relação a versões anteriores do Wan.
  • Colocação mais alta em rankings de avaliações de terceiros de texto-para-vídeo.
  • Melhora na consistência com múltiplos sujeitos e na preservação de referências.
  • Melhor integração de áudio do que muitos modelos de vídeo abertos anteriores.

A transparência formal de benchmarks ainda é limitada, portanto as afirmações de desempenho devem ser interpretadas com cautela.

Wan 2.7 vs. outros modelos de vídeo

RecursoWan 2.7Veo 3.1Seedance 2.0
Fluxos de trabalho nativos de áudioForteForteModerado
Consistência orientada por referênciasForteModeradoModerado
Controle de primeiro + último quadroSimParcialLimitado
Fluxos de trabalho de edição de vídeoSimSimLimitado
Resolução máxima comum1080PSaída cinematográfica de nível superior1080P
Suporte a múltiplas referênciasÊnfase forteModeradoModerado

Limitações do Wan 2.7

  • Duração de clipes curta em comparação com ferramentas de produção de longa duração.
  • A saída máxima de 1080P limita fluxos de trabalho de ultra-alta resolução.
  • Cenas com movimento rápido ainda podem produzir artefatos de instabilidade.
  • Fluxos de trabalho com múltiplas referências aumentam a complexidade e as exigências de engenharia de prompts.
  • A divulgação pública de benchmarks permanece relativamente escassa.

Casos de uso representativos

  1. Curtas-metragens e storyboards com consistência de personagens.
  2. Clipes de marketing com sincronização de áudio.
  3. Geração de vídeos para redes sociais.
  4. Visualização de produtos e trailers conceituais.
  5. Continuação de vídeo e fluxos de trabalho de interpolação de cenas.
  6. Animação de avatares e personagens baseada em referências.

Como usar a API de Vídeo do WAN 2.7 no CometAPI

Etapa 1: Experimente a WAN 2.7 Video API no Kie Al Playground

Primeiro, teste os recursos do WAN 2.7 usando a WAN 2.7 Video API no CometAPI Playground. Faça upload de imagens, adicione prompts ou use referências para pré-visualizar o vídeo WAN gerado antes de integrar o vídeo de IA do WAN 2.7 ao seu fluxo de produção.

Etapa 2: Obtenha a chave da API do WAN 2.7 e consulte a documentação da API

Obtenha a chave da API do WAN 2.7 no console do CometAPI e consulte a documentação. Entenda os endpoints, a autenticação e os parâmetros da WAN 2.7 Video API para dar suporte a fluxos de trabalho de texto-para-vídeo, imagem-para-vídeo e vídeo WAN.

Etapa 3: Gere vídeos de IA com o WAN 2.7 e integre-os ao seu fluxo de trabalho

Use a WAN 2.7 Video API para gerar vídeos de IA do WAN 2.7 com prompts, imagens ou referências. Integre as saídas do WAN 2.7 a fluxos de trabalho de produto, pipelines de conteúdo ou ferramentas de vídeo com IA para possibilitar a criação de vídeos em escala.

FAQ

Preços para Wan2.7

Explore preços competitivos para Wan2.7, 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.7 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.7

Acesse código de exemplo abrangente e recursos de API para Wan2.7 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.7 em seus projetos.

# Create a video with wan2.7
# 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.7" \
  -F "prompt=Create a cinematic detective sequence with clear timed shots. Shot 1 [0-2s]: a rainy city street at night, neon signs reflected in puddles. Shot 2 [2-4s]: a detective in a dark coat enters an old building. Shot 3 [4-5s]: close-up on a clue lit by a narrow flashlight beam." \
  -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.7
# 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.7" \
  -F "prompt=Create a cinematic detective sequence with clear timed shots. Shot 1 [0-2s]: a rainy city street at night, neon signs reflected in puddles. Shot 2 [2-4s]: a detective in a dark coat enters an old building. Shot 3 [4-5s]: close-up on a clue lit by a narrow flashlight beam." \
  -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.7 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.7"),
        "prompt": (None, "Create a cinematic detective sequence with clear timed shots. Shot 1 [0-2s]: a rainy city street at night, neon signs reflected in puddles. Shot 2 [2-4s]: a detective in a dark coat enters an old building. Shot 3 [4-5s]: close-up on a clue lit by a narrow flashlight beam."),
        "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.7 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.7");
formData.append("prompt", "Create a cinematic detective sequence with clear timed shots. Shot 1 [0-2s]: a rainy city street at night, neon signs reflected in puddles. Shot 2 [2-4s]: a detective in a dark coat enters an old building. Shot 3 [4-5s]: close-up on a clue lit by a narrow flashlight beam.");
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.7

O motivo pelo qual Wan2.7 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.7