The Wan 2.6 Image to Video Model (2026): Pricing and API

Wan 2.6 image to video is the start-frame mode of the Wan 2.6 video family: you give it one still picture and a short text prompt, and it returns a clip that animates that picture, 5, 10 or 15 seconds long, at 720p or 1080p. Unicorn API offers two versions of it, the original Wan 2.6 Image To Video released on December 17, 2025, and the cheaper Wan 2.6 Flash Image To Video released on October 12, 2026.

This guide covers how the model works, how Standard and Flash differ, what each clip costs in credits and dollars, working code that submits a job and polls for the result, how to write prompts for a start image, and straight answers to the questions people search for: is it free, is it open source, can you run it locally.

What is Wan 2.6 image to video?

Image-to-video (often shortened to I2V) means generating video from a picture instead of from text alone. The picture you supply becomes the starting point, so the subject, colours, lighting and composition of the clip come from your image. The prompt then tells the model what should move and how: a slow push-in, hair blowing in the wind, a product rotating on a turntable.

Wan is the video model family from Alibaba’s Wan team. Like most current video generators it is a diffusion model: it starts from noise and removes it step by step until frames appear that match the image and prompt. The 2.6 generation is pitched at short-form storytelling, and one of its input fields, multi_shots, controls whether a single generation can contain more than one shot, meaning a cut from one camera angle to another inside the same clip.

Through Unicorn API, Wan 2.6 image to video accepts these inputs:

• image_urls: a list containing the public URL of your start image.
• prompt: what should happen in the clip.
• duration: 5, 10 or 15 seconds.
• resolution: 720p or 1080p.
• multi_shots: single continuous shot or multiple shots.
• nsfw_checker: the content safety filter setting.
• audio (Flash only): whether to generate sound with the video.

The family also includes Wan 2.6 Text To Video for clips with no start image and Wan 2.6 Video To Video for restyling or extending existing footage. If you have a picture you want to bring to life, image-to-video is the one you want.

Wan 2.6 Image To Video vs Wan 2.6 Flash

Both versions take the same kind of input and support the same lengths and resolutions. The differences are price, release date and audio.

	Wan 2.6 Image To Video	Wan 2.6 Flash Image To Video
Model id	wan-2-6-image-to-video	wan-2-6-flash-image-to-video
Released	2025-12-17	2026-10-12
Durations	5, 10, 15 s	5, 10, 15 s
Resolutions	720p, 1080p	720p, 1080p
Audio generation	No	Optional (audio: true)
5 s at 720p	70 credits	20 credits silent, 40 with audio
5 s at 1080p	105 credits	30 credits silent, 60 with audio
15 s at 1080p	315 credits	90 credits silent, 180 with audio

Work it out per second and the gap is clear. Standard costs 14 credits per second at 720p and 21 at 1080p. Flash without audio costs 4 per second at 720p and 6 at 1080p, so it is about 3.5x cheaper at either resolution. Turning audio on doubles the Flash price, and even then it stays well under the Standard model.

What we can’t give you is a quality ranking, because we don’t publish benchmarks for these two. “Flash” usually signals a variant tuned for cost and speed, and the honest advice is to run the same three or four of your own images through both before you commit a batch. For product shots and simple camera moves, many people find the cheaper model is enough; for close-ups of faces or complex motion, compare carefully.

A sensible default: prototype on Flash at 720p without audio, then move only the clips you care about to 1080p, audio, or the Standard model.

How much does Wan 2.6 image to video cost?

Unicorn API prices everything in credits. On a monthly plan (Starter $25, Creator $50, Studio $100, Pro $200) each credit costs $0.01. Top-up credits cost $0.015 each and never expire. Full details are on the pricing page. Here is every Wan 2.6 image to video combination, with dollar figures at the plan rate:

Length	Resolution	Standard	Flash, silent	Flash, with audio
5 s	720p	70 ($0.70)	20 ($0.20)	40 ($0.40)
5 s	1080p	105 ($1.05)	30 ($0.30)	60 ($0.60)
10 s	720p	140 ($1.40)	40 ($0.40)	80 ($0.80)
10 s	1080p	210 ($2.10)	60 ($0.60)	120 ($1.20)
15 s	720p	210 ($2.10)	60 ($0.60)	120 ($1.20)
15 s	1080p	315 ($3.15)	90 ($0.90)	180 ($1.80)

A worked budget

Say you run a small online shop and want a 5 second loop for each of 100 product photos.

• Standard at 720p: 100 × 70 = 7,000 credits, or $70 on a plan.
• Flash at 720p, silent: 100 × 20 = 2,000 credits, or $20 on a plan.
• Flash at 1080p, silent: 100 × 30 = 3,000 credits, or $30.

The Starter plan’s 2,500 credits cover all 100 silent Flash clips at 720p with 500 credits left over for retries. The same plan would cover 35 Standard clips at that size. If you only generate occasionally, top-ups make sense: a silent 5 second Flash clip at 720p is $0.30 at the top-up rate, and the credits don’t expire.

Check the price before you run it

Both models also list an “any other combination” fallback price (105 credits for Standard, 20 for Flash) that applies when a request doesn’t match a row in the table. You don’t have to guess: POST /v1/models/price returns the exact cost of a request before you submit it, which is worth wiring into any batch job.

How to run Wan 2.6 image to video with the API

The whole flow is four steps: create a key, host your image at a public URL, submit a job, poll until it finishes. Video generation takes a while, so the API is asynchronous: POST /v1/jobs returns a job id straight away, and you check GET /v1/jobs/{id} until the status is succeeded.

1. Create an API key on the keys page and export it as UNICORN_API_KEY.
2. Upload your start image somewhere the API can fetch it (your own bucket, CDN or storage service) and copy the public URL.
3. Optionally ask for the price.
4. Submit the job and poll for the result.

Price check and job submission with curl

# 1. What will this request cost?
curl -s https://api.unicornapi.net/v1/models/price \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan-2-6-flash-image-to-video",
    "input": {
      "image_urls": ["https://example.com/sneaker.png"],
      "prompt": "The sneaker rotates slowly on a turntable, soft studio light, camera stays still",
      "duration": 5,
      "resolution": "720p",
      "audio": false
    }
  }'

# 2. Submit the job
curl -s https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan-2-6-flash-image-to-video",
    "input": {
      "image_urls": ["https://example.com/sneaker.png"],
      "prompt": "The sneaker rotates slowly on a turntable, soft studio light, camera stays still",
      "duration": 5,
      "resolution": "720p",
      "audio": false
    }
  }'

# 3. Check the job (replace JOB_ID with the id returned above)
curl -s https://api.unicornapi.net/v1/jobs/JOB_ID \
  -H "Authorization: Bearer $UNICORN_API_KEY"

A complete Python script with polling

import os
import time
import requests

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

body = {
    "model": "wan-2-6-flash-image-to-video",
    "input": {
        "image_urls": ["https://example.com/sneaker.png"],
        "prompt": (
            "The sneaker rotates slowly on a turntable, "
            "soft studio light, camera stays still"
        ),
        "duration": 5,
        "resolution": "720p",
        "audio": False,
    },
}

resp = requests.post(f"{API}/v1/jobs", json=body, headers=HEADERS, timeout=30)
resp.raise_for_status()
job_id = resp.json()["id"]
print("Submitted job", job_id)

while True:
    r = requests.get(f"{API}/v1/jobs/{job_id}", headers=HEADERS, timeout=30)
    r.raise_for_status()
    job = r.json()
    status = job["status"]
    if status == "succeeded":
        print("Video URL:", job["outputs"][0]["url"])
        break
    if status == "failed":
        raise RuntimeError(f"Job failed: {job}")
    time.sleep(5)  # still running, wait and check again

To use the Standard model instead, change model to wan-2-6-image-to-video and remove the audio field, since that model doesn’t accept it. To request several shots in one clip, add the multi_shots field; the exact accepted values are in the API documentation.

Two other ways in, if you’d rather not write code yet: the video playground lets you try Wan 2.6 image to video in the browser with the same credits, and the MCP setup lets Cursor, Claude Code and other coding agents call the API for you.

Writing prompts and choosing start images

The most common reason a Wan 2.6 image to video clip disappoints is a prompt that describes the picture instead of the motion. The model can already see the picture. Your words should spend their effort on what changes.

A prompt structure that works

• Subject motion: what the main subject does. “She turns her head toward the window and smiles.”
• Camera: how the view moves. “Slow push-in”, “camera stays locked off”, “gentle orbit to the left”.
• Atmosphere: secondary movement that sells the scene. “Steam rises from the cup”, “leaves drift past”, “light flickers”.

Keep it to one main action per 5 seconds. Asking for a person to stand up, walk across the room, open a door and wave in a 5 second clip usually produces rushed or warped motion. If you need a sequence of actions, use a longer duration or the multi-shot option.

A worked example

Start image: a ceramic coffee mug on a wooden café table, morning light from the left.

Weak prompt: “A ceramic coffee mug on a wooden table in a café with morning light.” This restates the image, so the model has to guess what to animate and often adds random drift.

Better prompt: “Steam curls up from the coffee, sunlight slowly brightens across the table, camera pushes in gently toward the mug.” Each phrase is a motion instruction, and the camera move gives the clip a clear direction.

Choosing the start image

• Crop first. The Wan 2.6 models on Unicorn API have no aspect_ratio field, so frame the image the way you want the video framed before you upload it: vertical for Reels and Shorts, horizontal for web headers.
• Use a sharp, well-lit image. Blur, heavy compression artefacts and tiny subjects get amplified once they start moving.
• Leave room for the motion. If the camera will push in or the subject will move right, make sure there is space in that direction.
• Avoid text in the image unless it can stay still. Lettering on a moving surface tends to warp.

Is Wan 2.6 free, open source or runnable locally?

These are the questions searchers ask most, so here are direct answers.

Is Wan 2.6 free?

Generating video takes serious GPU time, so hosted Wan 2.6 access is either paid or limited to small trial allowances on some sites. On Unicorn API you pay per clip with no minimum beyond a plan or a top-up, and the cheapest Wan 2.6 image to video request (Flash, 5 seconds, 720p, silent) costs 20 credits, which is $0.20 on a plan. Use the price endpoint or the playground to see costs before you spend anything on a batch.

Is Wan 2.6 open source?

The Wan family earned its open-source reputation from earlier versions: Wan 2.1 and Wan 2.2 were released with open weights that people run in tools like ComfyUI. Wan 2.6 has been offered as a hosted model, and we are not aware of a public weight release for it. That may change, so check the official Wan repositories for the current status, but don’t plan a project around downloading Wan 2.6 weights until they actually exist.

Can you run Wan 2.6 locally?

Only if the weights are published. The local Wan workflows you see on GitHub and Reddit run the open versions, mostly 2.1 and 2.2. If local generation matters more to you than the 2.6 improvements, use one of those. If you want Wan 2.6 output, an API is the practical route, and it saves you the GPU, the setup and the time spent on driver issues.

What about “spicy” or NSFW content?

Both Wan 2.6 image to video models expose an nsfw_checker input, which controls the content safety filter. What that filter permits, and what you are allowed to generate at all, is governed by the API’s terms of use, so read those before building anything in this area. Content involving real people without consent, or minors, is never acceptable regardless of filter settings.

Common mistakes with Wan 2.6 image to video

1. Using a private image URL. The API has to fetch the image. Links behind a login, expiring signed URLs with very short lifetimes, or localhost paths will fail. Test the URL in a private browser window first.
2. Sending a string instead of a list. The field is image_urls, plural, and it takes an array: ["https://..."], not a bare string.
3. Adding audio to the Standard model. Only Flash has the audio field. If you want sound, switch to wan-2-6-flash-image-to-video.
4. Picking durations outside 5, 10 and 15. Other values aren’t in the price table, so you may be billed the fallback price or get an error. Stick to the three supported lengths.
5. Prototyping at 1080p. Iterating on prompts at 1080p costs 1.5x as much as 720p for the same lesson. Get the motion right at 720p, then re-render the winners.
6. Polling too fast or giving up too early. Check every few seconds, not every few milliseconds, and handle the failed status so your script doesn’t loop forever.
7. Treating the output URL as permanent storage. Download the file from outputs[0].url and keep it in your own storage once the job succeeds.

Alternatives to Wan 2.6 for animating an image

Wan 2.6 image to video is a good default, but it isn’t the only option on the same API key. Switching models is a one-line change to the model field (plus any input field differences), so it costs little to compare.

Model	Lengths	Resolutions	5 s at 720p	Notes
Wan 2.6 Flash Image To Video	5, 10, 15 s	720p, 1080p	20 credits (silent)	Optional audio, multi-shot
Wan 2.6 Image To Video	5, 10, 15 s	720p, 1080p	70 credits	Original 2.6 release, multi-shot
Grok Imagine Video 1.5	1 to 15 s	480p, 720p, 1080p	22.5 credits	Aspect ratio control, can be busy at peak times
Kling 4.0 Flash Keyframe To Video	Set by duration	720p	85 credits	17 credits per second, uses first_frame_url

Grok Imagine Video 1.5 is image-to-video only, priced per second, and supports any length from 1 to 15 seconds plus a 480p tier for cheap drafts. It also has an aspect_ratio field, which Wan 2.6 lacks. Note that it takes the start frame in a field called image rather than image_urls.

Kling 4.0 Flash Keyframe To Video costs 17 credits per second at 720p and takes the start image as first_frame_url. At 5 seconds that is more than four times the silent Wan 2.6 Flash price, so it earns its place when you prefer Kling’s look for a particular shot rather than as a bulk option.

If you are deciding between Wan generations, our guide to Wan 2.7 image to video covers the newer release’s modes and pricing. And when your starting point is footage rather than a still, Wan 2.6 Flash Video to Video works the same way with video_urls in place of image_urls. Browse the full model catalog for everything else.

For most projects the path is simple: start with Wan 2.6 Flash at 720p and no audio, get the prompt and start image right, then spend credits on 1080p, sound or the Standard model only where the clip actually needs it.