Wan 2.7 Image to Video (2026): Pricing, Modes and API Code

Wan 2.7 image to video is the part of Alibaba’s Wan 2.7 family you reach for when you already have the picture and want it to move. Below: what the model actually accepts, what a clip costs, a complete script you can run today, and the habits that separate a usable clip from a wasted render.

What is Wan 2.7 image to video?

Image-to-video (often shortened to I2V) means a video model that is conditioned on an image: instead of inventing a scene from text alone, it treats your picture as the first frame and generates the motion that follows. Under the hood it is a diffusion model, a type of generative model that starts from noise and refines it step by step toward an output that matches its inputs. Your image pins down what the scene looks like, so your text prompt only has to describe what happens.

“Wan 2.7” gets used loosely online for several different models, which causes a lot of confusion in search results and on Reddit threads. On Unicorn API they are separate, each with its own id and page:

• Wan 2.7 (id wan/2-7-image-to-video): image-to-video only. Animates a start frame for 2 to 15 seconds at 720p or 1080p. This is the model this post is about.
• Wan 2.7 Text to Video: generates video from a prompt alone, with an optional audio input.
• Wan 2.7 Reference to Video: builds a clip around reference images, a reference video or a reference voice, with an optional first frame.
• Wan 2.7 Image and Wan 2.7 Image Pro: still-image models for generation and editing with up to 9 reference images. Image Pro is the one with 4K text-to-image output.

That last point explains a claim you will see on some landing pages: 4K. On Unicorn API, the Wan 2.7 image to video model outputs 720p or 1080p. The 4K figure belongs to the Image Pro still-image tier, so if you need a 4K asset, it will be a picture, not a clip.

Inputs and modes: start frame, end frame, continuation and audio

The model has one endpoint but several jobs, decided by which inputs you send. Here is every input field it accepts, in plain terms:

• image: the start frame. This is the picture that comes to life.
• prompt: what should happen. Describe motion and camera, not the contents of the picture.
• duration: clip length in whole seconds, from 2 to 15.
• resolution: 720p or 1080p.
• end_image: an optional last frame. The model interpolates a path from the start frame to this one, which is useful for transitions and before-and-after shots.
• first_clip_url: an existing clip to continue, so you can chain segments into something longer than 15 seconds.
• driving_audio_url: an audio file that drives the animation, for example to make a character’s movement follow speech or music.
• mode: selects which of these behaviours you want. The accepted values are listed in the API documentation; check there rather than guessing strings.
• negative_prompt: things you want to avoid, such as “warping, extra fingers, text”.
• prompt_extend: lets the service expand a short prompt into a more detailed one. Handy for quick tests, less handy when you need exact control.
• seed: fixes the random starting point, so the same inputs give a comparable result. Essential for A/B testing prompts.
• watermark: toggles a watermark on the output.

Notice what is missing: there is no aspect ratio field. You control framing through the start frame itself, so crop or generate your image at the shape you want the video to be (16:9 for YouTube, 9:16 for Reels and Shorts) before you send it.

How much does Wan 2.7 image to video cost?

Pricing is flat per second and depends only on resolution: 16 credits per second at 720p and 24 credits per second at 1080p. Monthly plans give credits at $0.01 each (Starter $25, Creator $50, Studio $100, Pro $200 per month), and top-ups cost $0.015 per credit and never expire. Here is what common lengths cost:

Duration	720p credits	1080p credits	720p on a plan	1080p on a plan	1080p via top-up
2 s	32	48	$0.32	$0.48	$0.72
5 s	80	120	$0.80	$1.20	$1.80
8 s	128	192	$1.28	$1.92	$2.88
10 s	160	240	$1.60	$2.40	$3.60
15 s	240	360	$2.40	$3.60	$5.40

Two practical consequences. First, 1080p costs 1.5x as much as 720p for the same length, so drafting at 720p and only rendering finals at 1080p cuts iteration cost by a third. Second, length is the bigger lever: a 15-second 1080p clip costs about 7x a 2-second 720p test. Short tests first, long renders last.

You never have to estimate. POST /v1/models/price returns the exact price of a request before you run it, which is worth wiring into any app that lets end users pick duration and resolution. Plan details are on the pricing page.

How to call the Wan 2.7 image to video API

Every media model on Unicorn API follows the same pattern: create a job, poll until it finishes, download the output. That means the code below also works for the other video models with only the model id and inputs changed.

1. Create an API key on the keys page and export it as UNICORN_API_KEY.
2. Host your start frame at a publicly reachable URL.
3. Check the price, create the job with POST /v1/jobs, then poll GET /v1/jobs/{id} until status is "succeeded".
4. Read the video URL from outputs[0].url and download it.

Quick test 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-to-video",
    "input": {
      "image": "https://example.com/start-frame.jpg",
      "prompt": "Slow push-in, steam rises from the mug, morning light shifts across the table",
      "duration": 5,
      "resolution": "720p"
    }
  }'

# Then poll with the id from the response:
curl https://api.unicornapi.net/v1/jobs/JOB_ID \
  -H "Authorization: Bearer $UNICORN_API_KEY"

Complete Python script

import os
import time
import requests

API = "https://api.unicornapi.net"
HEADERS = {
    "Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}",
    "Content-Type": "application/json",
}

body = {
    "model": "wan/2-7-image-to-video",
    "input": {
        "image": "https://example.com/start-frame.jpg",
        "prompt": (
            "Slow push-in on the mug, steam curls upward, "
            "soft morning light drifts across the wooden table"
        ),
        "negative_prompt": "warping, flicker, distorted text, extra objects",
        "duration": 5,
        "resolution": "720p",
        "seed": 42,
    },
}

# 1. Check the exact price before spending credits
price = requests.post(f"{API}/v1/models/price", json=body, headers=HEADERS, timeout=30)
price.raise_for_status()
print("Price:", price.json())

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

# 3. Poll until it finishes
while True:
    job = requests.get(f"{API}/v1/jobs/{job_id}", headers=HEADERS, timeout=30).json()
    status = job["status"]
    if status == "succeeded":
        break
    if status == "failed":  # see /docs for the full list of statuses
        raise RuntimeError(f"Job failed: {job}")
    print("Status:", status)
    time.sleep(5)

# 4. Download the video
video_url = job["outputs"][0]["url"]
with requests.get(video_url, stream=True, timeout=120) as r:
    r.raise_for_status()
    with open("clip.mp4", "wb") as f:
        for chunk in r.iter_content(chunk_size=1 << 20):
            f.write(chunk)

print("Saved clip.mp4 from", video_url)

To add an end frame, a clip to continue or driving audio, add end_image, first_clip_url or driving_audio_url to input and set mode to the matching value from the docs. If you work inside Cursor or Claude Code, the MCP setup lets your agent make these calls for you, and the browser playground is the quickest way to make start frames by hand.

Prompts and start frames that animate well

Most bad clips trace back to the input, not the model. The start frame sets the ceiling on quality, and the prompt decides whether the motion is coherent.

Start frame rules

• Leave room to move. A subject cropped tight against the frame edge has nowhere to go. Give the camera and the subject some space.
• Avoid fine text and logos you need to stay legible. Motion can smear small type. If text matters, keep it large or add it in editing afterwards.
• Match the final shape. Since there is no aspect ratio input, a square image gives you a square-framed problem when you wanted vertical video.
• Clean lighting beats busy lighting. Simple, consistent light gives the model less to keep track of between frames.

Prompt rules

• Describe motion, not the picture. The model can already see a red car on a coastal road. Tell it “the car drives away from camera, dust lifts behind the wheels, camera stays still”.
• One main action per clip. Three simultaneous events in five seconds tends to produce mush. Chain clips with first_clip_url instead.
• Use camera language. “Slow push-in”, “static shot”, “pan left”, “handheld” are short, clear instructions.
• Turn off prompt_extend when you need precision. Expansion helps vague prompts but can add details you did not ask for.

Worked example: a product clip for a store page

Say you sell coffee mugs and want a 5-second hero loop. A sensible pipeline:

1. Generate the start frame with Wan 2.7 Image at 16:9. It is 4.8 credits per image, rounded up to 5 credits.
2. Run three 5-second drafts at 720p with the same seed and three prompt variations: 3 x 80 = 240 credits.
3. Render the best prompt at 1080p: 120 credits.

Total: 365 credits, or $3.65 on a monthly plan. Skipping the drafts and rendering four 1080p variations instead would cost 480 credits for the clips alone, about a third more, for the same information. If you want cheaper start frames for rough storyboards, Nano Banana 2 Lite costs 4 credits per image, and GPT Image 1.5 is a good pick when the frame contains text that must be legible.

Is Wan 2.7 open source? Hugging Face, GitHub and ComfyUI

This is one of the most common questions around Wan 2.7 image to video, and the honest answer is: check the source before you plan around it. Several sites call Wan 2.7 open source, and earlier Wan releases such as Wan 2.1 were published with open weights and became a staple of local ComfyUI workflows. That history is why people search for “Wan 2.7 Hugging Face” and “Wan 2.7 GitHub” expecting a download.

Hosted availability and open weights are separate decisions for a model maker, though. Before you buy a GPU or spend a weekend on a ComfyUI graph, confirm on the official Wan pages on Hugging Face and GitHub that weights for the exact 2.7 variant you need are published, and read the license that applies to them. Treat claims in Reddit threads and third-party generator sites as leads, not confirmation.

Even when weights are available, running locally has real costs: high-memory GPUs for 1080p, long render times on consumer cards, and the time spent maintaining workflows as nodes change. A hosted API is the better fit when:

• you need the model inside a product, where users cannot wait for a local queue;
• your volume is uneven, so paying per clip beats paying for idle hardware;
• you want the same code to switch between Wan, Grok and other video models.

The two approaches also combine well. A ComfyUI user can keep local image steps and call the hosted video model from a small custom node that posts to /v1/jobs and fetches the result.

Wan 2.7 vs other image-to-video models

Wan 2.7 image to video is not the cheapest way to animate a picture, so it is worth knowing when it earns its price. Here is how it lines up against the other image-to-video options in the model catalog, using a 5-second 1080p clip as the yardstick:

Model	Lengths	Resolutions	5 s at 1080p	Distinctive inputs
Wan 2.7 (image to video)	2-15 s	720p, 1080p	120 credits	End frame, clip continuation, driving audio, negative prompt, seed
Grok Imagine Video 1.5	1-15 s	480p, 720p, 1080p	40 credits	Aspect ratio control; can be busy at peak times
Grok Imagine Video 1.0	6-30 s	480p, 720p, 1080p	48 credits (6 s minimum)	Longer single clips, text-to-video too
Wan 2.7 Reference to Video	set by duration	720p, 1080p	120 credits	Reference images, reference video, reference voice

Pick Wan 2.7 when you need control: a fixed end frame for a transition, a continuation of an existing shot, motion driven by an audio track, or a negative prompt and seed for repeatable iteration. Pick Grok Imagine Video 1.5 when you need volume at low cost per second and the motion only has to look good, not hit an exact final frame; at 480p a 5-second draft is 12 credits. Pick Grok Imagine Video 1.0 when you want one clip longer than 15 seconds without chaining. Pick Reference to Video when the job is “keep this character or product consistent” rather than “animate this exact frame”. For a deeper look at the Grok side, see our breakdown of Grok Imagine pricing.

Common mistakes with Wan 2.7 image to video

These are the errors that burn the most credits, roughly in order of how often they happen:

1. Rendering finals before testing. A 15-second 1080p render is 360 credits. A 2-second 720p test of the same prompt is 32. Test motion short and cheap, then scale.
2. Not fixing the seed. Without a seed, every change in the output could come from your prompt edit or from randomness, and you cannot tell which. Fix it while you iterate.
3. Describing the image instead of the motion. Re-describing what is already visible wastes the prompt and sometimes nudges the model to redraw parts of the frame.
4. Sending the wrong shape. Feeding a landscape image when you need vertical video, then cropping afterwards, throws away resolution you paid for.
5. Asking for too much in one clip. Long, multi-action prompts in short durations produce rushed or incoherent motion. Split the idea into segments and continue each clip with first_clip_url.
6. Hard-coding prices. If your app shows users a cost, read it from /v1/models/price rather than copying numbers into code.
7. Confusing the family members. Sending a request for 4K video or a text-only prompt to the image-to-video model will not give you what you expect. Use Image Pro for 4K stills and Text to Video when you have no start frame.

Get those right and Wan 2.7 image to video becomes a dependable step in a pipeline: make or pick a strong frame, draft the motion cheaply, render the keeper at 1080p, and chain clips when the story needs more than 15 seconds. One API key covers the image model for the frame, the video model for the motion and any alternative you want to compare against, all billed in the same credits.