Wan 2.7 Open Source? Weights, ComfyUI and API (2026)

The short answer to the Wan 2.7 open source question is that it depends on what you mean by “open”: the Wan family built its reputation on downloadable weights, but Wan 2.7 is mainly offered today as a hosted model you call through an API. This post explains what has been released, how to verify it yourself on Hugging Face and GitHub, what Wan 2.7 actually does, what it costs per clip and per image, and how to start generating with working code.

Is Wan 2.7 open source?

Wan is Alibaba’s family of video and image generation models. Its early versions are the reason so many people search for “Wan 2.7 open source” at all. Wan 2.1 and Wan 2.2 were published with downloadable weights under a permissive license, and they became some of the most popular local video models in the community, especially in ComfyUI.

Things changed with Wan 2.5. It arrived as a hosted preview rather than a weights release, and the reaction on Reddit was blunt: people who had built workflows on the open versions felt misled, and threads asked why nobody could find a download. Later versions have followed a similar hosted-first pattern. Wan 2.7 launched in April 2026 as a set of video and image models available through Alibaba’s own platform and through third-party APIs, including partner apps such as Picsart.

So where does that leave the Wan 2.7 open source question? Some articles describe Wan 2.7 as “the newest release in Alibaba’s open-source Wan series”. That is accurate about the series history, but it does not by itself mean the 2.7 weights are downloadable. Licensing decisions can also change after launch, so the honest answer is a method, not a slogan:

• Look for a Wan 2.7 checkpoint in the official Wan-Video organisation on Hugging Face.
• Look for a matching code release and license file in the official Wan-Video GitHub organisation.
• If both exist with a clear license, you can run it locally. If they do not, Wan 2.7 is a hosted model for you, whatever a blog headline says.

Open source vs open weights: what the terms mean

A lot of the confusion around Wan 2.7 open source claims comes from three terms that get used interchangeably.

• Open source, in the strict sense, means the code and the things needed to rebuild the software are published under a license that allows use, modification and redistribution. For AI models, very few releases meet that bar, because training data is rarely published.
• Open weights means the trained model file (the “weights”, the billions of numbers the model learned) is downloadable, usually alongside inference code. You can run it on your own GPU and fine-tune it, subject to the license. Wan 2.1 and 2.2 fall into this category.
• Hosted or API access means the model runs on someone else’s servers. You send a prompt, you get a result, and you never see the weights. You pay per generation instead of buying hardware.

When people ask whether Wan 2.7 is open source, they almost always mean the second one: can I download it and run it in ComfyUI on my own machine? That is a narrower, checkable question.

What Wan 2.7 includes: video and image models

“Wan 2.7” is not one model. It is a family covering text-to-video, image-to-video, reference-to-video and image generation. Here is what each one does, based on the inputs each model accepts.

Wan 2.7 image to video

Wan 2.7 image to video animates a start frame for 2 to 15 seconds at 720p or 1080p. Besides the start image and prompt, it accepts an end_image for first-to-last-frame control (you set where the shot begins and ends and the model fills the motion in between), a driving_audio_url for audio-driven motion, a negative_prompt to steer away from unwanted content, and prompt_extend, which lets the service expand a short prompt into a more detailed one.

Wan 2.7 Text to Video

Wan 2.7 Text to Video generates a clip from a prompt alone, with options for aspect ratio, duration, resolution, a seed for reproducibility and an audio_url input.

Wan 2.7 Reference to Video

Wan 2.7 Reference to Video is the multi-reference model. It accepts a reference_image, reference_video and reference_voice, plus an optional first_frame. This is the one to use when you need a specific character, product or voice to stay consistent across shots.

Wan 2.7 Image and Wan 2.7 Image Pro

Wan 2.7 Image generates and edits at 1K or 2K with up to 9 reference images. Wan 2.7 Image Pro is the higher-quality tier, with 4K output for text-to-image and the same 9-reference limit. Both support a thinking_mode option, a color_palette input, bbox_list for region-targeted edits, and enable_sequential for sets of related images. Aspect ratios are 1:1, 4:3, 3:4, 16:9, 9:16 and 21:9.

Wan 2.7 on Hugging Face, GitHub and ComfyUI

Three of the most common related searches are “Wan 2.7 Hugging Face”, “Wan 2.7 GitHub” and “Wan 2.7 ComfyUI”. Each has a practical answer.

Hugging Face

Search Hugging Face for “Wan” and you will find hundreds of repositories. Most are fine-tunes, LoRAs (small add-on files that teach a base model a style or character), quantised copies of older versions, or reuploads. A repository is only a genuine Wan 2.7 release if it sits under the official Wan-Video organisation, names version 2.7 explicitly in its model card and ships a license. Anything else is probably Wan 2.1 or 2.2 under a misleading name, or worse.

GitHub

The official Wan-Video GitHub organisation hosts the inference code for the open versions. It also hosts Wan-skills, a set of skills that let AI agents generate images and video through API calls. That repository is useful, but it is an API client toolkit, not a weights release, and finding it is not evidence that Wan 2.7 open source weights exist.

ComfyUI

ComfyUI is a node-based interface for running diffusion models locally. Native Wan workflows there depend on local checkpoints, so a native Wan 2.7 workflow needs downloadable 2.7 weights. Without them, ComfyUI can still reach Wan 2.7 through API nodes that send the request to a hosted service and drop the result back into your graph. If fully local generation is a hard requirement, the open Wan 2.1 and 2.2 models already have mature workflows.

Apps and APKs

“Wan 2.7 open source APK” is a frequent search. Be careful. Video models of this class need serious GPU hardware, so a phone app claiming to run Wan 2.7 offline is either sending your prompts to a server or is not what it claims. Install apps only from publishers you can identify.

How to use Wan 2.7 through an API (with code)

If the weights are not available to you, or you do not want to manage GPUs, the API route takes a few minutes. Unicorn API gives you one key and one bill for every Wan 2.7 model, plus image, video, audio and chat models from other providers. Create a key on the API keys page, set it as UNICORN_API_KEY, and you are ready.

Media generation works as a job: you POST a request to /v1/jobs, receive a job id, then poll GET /v1/jobs/{id} until the status is "succeeded" and read the video URL from job.outputs[0].url.

Example: Wan 2.7 image to video in Python

import os
import time
import requests

API = "https://api.unicornapi.net"
HEADERS = {"Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}"}

body = {
    "model": "wan/2-7-image-to-video",
    "input": {
        "image": "https://example.com/start-frame.jpg",
        "prompt": "The camera slowly pushes in as waves break against the rocks at sunset",
        "negative_prompt": "blurry, distorted faces, text overlays",
        "duration": 5,
        "resolution": "720p",
        "seed": 42
    }
}

resp = requests.post(f"{API}/v1/jobs", json=body, headers=HEADERS)
resp.raise_for_status()
job = resp.json()
print("Job created:", job["id"])

while job["status"] not in ("succeeded", "failed"):
    time.sleep(5)
    resp = requests.get(f"{API}/v1/jobs/{job['id']}", headers=HEADERS)
    resp.raise_for_status()
    job = resp.json()
    print("Status:", job["status"])

if job["status"] == "succeeded":
    print("Video URL:", job["outputs"][0]["url"])
else:
    print("Job failed:", job)

This 5-second 720p clip costs 80 credits. Fixing the seed means that if you rerun with the same inputs, you get comparable output, which makes prompt tweaking much easier to judge.

Example: Wan 2.7 Image with curl

curl -X POST https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan-2.7-image",
    "input": {
      "prompt": "A red fox resting in a snowy forest at dawn, soft light, highly detailed",
      "aspect_ratio": "16:9",
      "n": 2
    }
  }'

Poll the returned job id the same way. A good pattern is to generate start frames with Wan 2.7 Image, pick the best one, then pass its URL as the image input to the image-to-video model. If you prefer clicking to coding, the browser playground runs the same models. If you work in Cursor or Claude Code, the agent integration lets your coding agent call these models directly. Full request details are in the API documentation.

Wan 2.7 pricing per clip and per image

Unicorn API prices everything in credits. Monthly plans give credits at $0.01 each (Starter $25, Creator $50, Studio $100, Pro $200 per month). Top-ups cost $0.015 per credit and never expire. You can get the exact price of any request before running it with POST /v1/models/price, which is worth doing in any batch script. See plans and credit prices for details.

Model	Price	Example	Example cost on a plan
Wan 2.7 image to video	16 credits/s at 720p, 24 credits/s at 1080p	5 s, 720p	80 credits ($0.80)
Wan 2.7 image to video	same	10 s, 1080p	240 credits ($2.40)
Wan 2.7 Text to Video	16 credits/s at 720p, 24 credits/s at 1080p	5 s, 1080p	120 credits ($1.20)
Wan 2.7 Reference to Video	16 credits/s at 720p, 24 credits/s at 1080p	8 s, 720p	128 credits ($1.28)
Wan 2.7 Image	4.8 credits per image	1 image (rounded up)	5 credits ($0.05)
Wan 2.7 Image Pro	12 credits per image	1 image	12 credits ($0.12)

Prices round up to whole credits per request, so batching images with n is slightly more efficient: four Wan 2.7 Images in one request is 19.2, rounded to 20 credits, rather than 5 credits each.

How Wan 2.7 compares with nearby options

If cost per second matters more than the Wan feature set, Grok Imagine Video 1.5 animates a start frame at 480p, 720p or 1080p for 22.5 credits for 5 seconds at 720p, though it can be busy at peak times. Grok Imagine Video 1.0 handles longer clips of 6 to 30 seconds at the same per-second rate. For stills, Nano Banana 2 Lite is 4 credits per image with up to 10 references, and GPT Image 1.5 is strong on legible text from 3 credits at low quality. Wan 2.7 earns its price where you need first-and-last-frame control, audio-driven motion or multi-reference consistency. The full model catalog lists every option.

Running Wan locally vs using the API: trade-offs

Even if a Wan 2.7 open source release appears, local and hosted are not interchangeable. Here is how the choice usually plays out.

	Local (open weights)	Hosted API
Upfront cost	A capable GPU or rented GPU time	None; pay per generation
Marginal cost	Electricity and your time	Fixed credits per clip or image
Setup	Install drivers, ComfyUI, checkpoints, workflows	Create a key, send JSON
Fine-tuning and LoRAs	Full control	Limited to the inputs the model exposes
Privacy	Data never leaves your machine	Inputs go to the provider
Access to newest versions	Only versions with released weights	Wan 2.7 available now
Scaling	Bounded by your hardware	Run many jobs in parallel

A sensible split many teams use: keep an open Wan 2.1 or 2.2 setup for experiments, custom LoRAs or sensitive material, and call Wan 2.7 by API for production clips where the newer model’s quality and controls matter. Because API pricing is per generation, you can measure exactly what a finished video costs and decide whether local hardware would ever pay for itself at your volume.

Common mistakes people make with Wan 2.7

1. Trusting the “open source” label in a headline. The Wan series history is open, but each version’s license is its own decision. Check the official repositories before planning a product around local Wan 2.7 open source weights.
2. Downloading unofficial “Wan 2.7” checkpoints. Unverified model files can be mislabelled older versions, broken, or in older pickle-based formats that can execute code when loaded. Prefer safetensors files from the official organisation.
3. Confusing the models. The image-to-video model needs a start frame; send a prompt alone and you will not get the result you expect. Use Text to Video for prompt-only clips and Reference to Video when you have characters or voices to preserve.
4. Starting at 1080p. Draft at 720p and short durations, lock your prompt and seed, then render the final at 1080p. A 5-second 720p test is 80 credits versus 120 at 1080p.
5. Long prompts with prompt_extend switched on. Prompt extension is useful for short ideas, but it can dilute a carefully written prompt. Turn it off when you need precise control.
6. Not checking price in batch jobs. Durations multiply cost. Call POST /v1/models/price before a large run so a typo in duration does not surprise you.
7. Using Image Pro for everything. At 12 credits versus 4.8, Image Pro is for finals and 4K text-to-image. Iterate on the standard tier first.

The practical takeaway: treat the Wan 2.7 open source story as a moving target, verify it at the source, and do not let it block you. If the weights are there, run them. If not, the full Wan 2.7 family is a single API call away, priced per clip and checkable before you spend a credit.