Can Wan 2.7 API generate videos from both images and text prompts?

Yes. Wan 2.7 supports text-to-video and image-to-video workflows, including start-frame guided generation and continuation tasks.

How does Wan 2.7 API maintain character consistency across scenes?

Wan 2.7 uses reference-driven workflows that allow image or video references to preserve identity, clothing, props, and style between shots.

What video resolutions and durations does Wan 2.7 support?

Wan 2.7 commonly supports 720P and 1080P output with clip durations ranging from roughly 2 to 15 seconds depending on workflow configuration.

When should I use Wan 2.7 instead of Veo 3.1?

Choose Wan 2.7 when you need stronger controllability features such as frame anchoring, reference workflows, or editing-heavy pipelines. Veo-style models may be stronger for cinematic realism in some cases.

Does Wan 2.7 support audio generation and lip sync?

Yes. Wan 2.7 includes audio-aware workflows with voice references, sound generation, and lip-sync-oriented capabilities.

Can Wan 2.7 API edit existing videos instead of generating new ones?

Yes. The model family includes editing workflows for transforming, extending, or restyling existing clips.

What are the main limitations of Wan 2.7 video generation?

The biggest limitations are short clip durations, 1080P output ceilings, and occasional instability during highly dynamic scenes.

Is Wan 2.7 suitable for production marketing videos and social media content?

Yes. Its combination of consistency controls, editing tools, and multimodal inputs makes it suitable for ads, social clips, and short-form storytelling.

Affordable Wan2.7 API | text-to-video

Technical Specifications of Wan 2.7

Item	Wan 2.7 (Video Suite)
Provider	Alibaba Tongyi Lab
Model family	Wan 2.7 Video Suite
Architecture	27B parameter Mixture-of-Experts (MoE)
Input types	Text, images, videos, audio references
Output types	Generated / edited video clips with optional audio
Supported modes	Text-to-video (T2V), Image-to-video (I2V), Reference-to-video (R2V), Video Editing
Resolution	720P and 1080P outputs
Video duration	2–15 seconds
Audio support	Native audio generation, voice references, lip-sync workflows
Reference capability	Multi-reference images/videos, identity consistency
Character consistency	Supports up to multiple reference subjects depending on workflow
Release generation	Major successor to Wan 2.6

What is Wan 2.7?

Wan 2.7 is Alibaba’s flagship multimodal video generation suite built for controllable AI filmmaking workflows rather than simple prompt-to-video creation. The model family combines generation, editing, continuation, and reference-driven consistency into one system, enabling creators to build short cinematic clips with stronger subject preservation and scene control.

Unlike earlier video generators that focused mostly on prompt quality, Wan 2.7 emphasizes controllability through frame anchoring, reference inputs, audio synchronization, and structured multi-shot workflows.

Main Features of Wan 2.7

Thinking Mode planning pipeline: The model plans scene composition and motion before rendering, improving prompt adherence and reducing coherence failures.
First-frame and last-frame control: Users can define opening and ending frames so the system interpolates motion between them.
Reference-driven identity consistency: Maintain character appearance, clothing, objects, and style across multiple shots.
Native multimodal workflows: Supports text, image, audio, and video references inside the same workflow.
Integrated audio generation: Background music, environmental sounds, and voice synchronization can be generated alongside visuals.
Editing and continuation support: Existing videos can be extended, transformed, or re-styled without rebuilding from scratch.

Benchmark Performance of Wan 2.7

Public benchmark disclosure for Wan 2.7 remains limited compared with text LLMs, but third-party evaluations and community testing indicate notable improvements in motion stability, prompt adherence, and controllability over Wan 2.6.

Reported ecosystem observations include:

Stronger motion continuity versus earlier Wan releases.
Higher leaderboard placement in third-party text-to-video evaluations.
Improved multi-subject consistency and reference preservation.
Better audio integration than many earlier open video models.

Formal benchmark transparency is still limited, so performance claims should be interpreted cautiously.

Wan 2.7 vs Other Video Models

Feature	Wan 2.7	Veo 3.1	Seedance 2.0
Native audio workflows	Strong	Strong	Moderate
Reference-driven consistency	Strong	Moderate	Moderate
First + Last Frame control	Yes	Partial	Limited
Video editing workflows	Yes	Yes	Limited
Max common resolution	1080P	Higher-end cinematic output	1080P
Multi-reference support	Strong emphasis	Moderate	Moderate

Limitations of Wan 2.7

Short clip duration compared with long-form production tools.
1080P maximum output limits ultra-high-resolution workflows.
Fast motion scenes may still produce instability artifacts.
Multi-reference workflows increase complexity and prompt engineering requirements.
Public benchmark reporting remains relatively sparse.

Representative Use Cases

Character-consistent short films and storyboards.
Marketing clips with audio synchronization.
Social media video generation.
Product visualization and concept trailers.
Video continuation and scene interpolation workflows.
Reference-based avatar and character animation.

How to Use the WAN 2.7 Video API in CometAPI

Step 1: Try the WAN 2.7 Video API in the Kie Al Playground

First, test the WAN 2.7 functionality using the WAN 2.7 Video API in the CometAPI Playground. Upload images, add prompts, or use references to preview the generated WAN video before integrating the WAN 2.7 AI video into your production workflow.

Step 2: Obtain the WAN 2.7 API key and review the API documentation

Obtain the WAN 2.7 API key from the CometAPI console and review the documentation. Understand the WAN 2.7 Video API endpoints, authentication, and parameters to support text-to-video, image-to-video, and WAN video workflows.

Step 3: Generate WAN 2.7 AI videos and integrate them into your workflow

Use the WAN 2.7 Video API to generate WAN 2.7 AI videos with prompts, images, or references. Integrate WAN 2.7 outputs into product workflows, content pipelines, or AI video tools to enable scalable video creation.

Pricing for Wan2.7

Explore competitive pricing for Wan2.7, designed to fit various budgets and usage needs. Our flexible plans ensure you only pay for what you use, making it easy to scale as your requirements grow. Discover how Wan2.7 can enhance your projects while keeping costs manageable.

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

Sample code and API for Wan2.7

Access comprehensive sample code and API resources for Wan2.7 to streamline your integration process. Our detailed documentation provides step-by-step guidance, helping you leverage the full potential of Wan2.7 in your projects.

Python
JavaScript
Curl

# 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("
Checking 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"
Downloading 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)

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

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

Versions of Wan2.7

The reason Wan2.7 has multiple snapshots may include potential factors such as variations in output after updates requiring older snapshots for consistency, providing developers a transition period for adaptation and migration, and different snapshots corresponding to global or regional endpoints to optimize user experience. For detailed differences between versions, please refer to the official documentation.

version
wan2.7

Wan2.7