Wan 2.2 Image to Video API: I2V Pricing & Code

The short answer: a Wan 2.2 image-to-video API call is an async job

A Wan 2.2 image-to-video API takes a first-frame image plus a motion prompt, submits an asynchronous generation task, and returns a short generated clip when it finishes. You never hold a synchronous response: you send the job, poll a task identifier until it reaches a terminal state, then download the result. Alibaba’s official Model Studio documents this as the first-frame image-to-video contract, and every hosting platform and aggregator that carries Wan 2.2 I2V wraps the same submit–poll–retrieve shape behind its own endpoint.

The more important question is the one the SERP does not answer: Wan 2.2 is no longer Alibaba’s current I2V model. Wan 2.7 shipped in April 2026, and the wan2.2-i2v-plus model page itself describes it as “an older generation image-to-video model… maintained for backward compatibility” and advises against using it for new creations. The pricing and code below are therefore framed as an integration-and-migration guide: how to call Wan 2.2 I2V if you must, what it costs, and when you should move to Wan 2.7 instead. Modellix is an AI model API aggregator and has a commercial interest in this comparison — the rates shown are a same-day snapshot, not a claim that any route is always the cheapest.

What Wan 2.2 I2V is — and why it is already the “older generation”

Wan 2.2 is the second-generation family of open-weight video models from Alibaba’s Tongyi Lab. The family spans several variants, and the ones that matter for image-to-video are:

• Wan2.2-I2V-A14B — the 14B image-to-video MoE model, supporting 480P and 720P output. This is the model the official Wan2.2 GitHub repository documents for I2V inference, with weights on Hugging Face.
• Wan2.2-TI2V-5B — the hybrid text-image-to-video 5B model, 720P at 24 FPS, designed to run on consumer GPUs.

The family uses a Mixture-of-Experts architecture that routes the denoising process across specialized experts, which is how a 14B model stays cost-competitive with smaller dense models. The weights are open (Apache 2.0, per the ComfyUI Wan 2.2 tutorial), so you have three realistic execution paths: self-hosting the weights, calling Alibaba’s hosted Model Studio API, or calling the model through an aggregator like Modellix. Self-hosting the A14B I2V model is the “free” option in the strict sense — you only pay for GPUs — but it needs roughly 80 GB of VRAM for single-GPU inference, which is why most teams end up calling an API instead.

The “older generation” label is not editorializing. The wan2.2-i2v-plus model page states it is a legacy model “maintained for backward compatibility,” and the platform’s Wan 2.7 API guide documents the current-generation suite with native audio and longer clips. If you are starting a new integration today, the version decision in the last section of this guide matters more than any parameter below.

The version line matters for a second reason: 2.2 sits between two generations of integration habits. The 2.1 era established the first-frame contract, 2.2 refined it with the MoE architecture and better motion handling, and 2.7 added thinking-mode prompt planning, longer clips, and native audio. Code written against 2.2’s first-frame contract transfers forward more easily than code written against 2.1-era assumptions — which is one of the few genuinely good reasons a legacy route stays in production catalogs: the request shape is stable, documented, and widely mirrored across hosting platforms.

Wan 2.2 I2V API pricing: per-second rates as of August 7, 2026

Wan 2.2 I2V is billed per second of generated video, not per clip. The practical cost of a job is the per-second rate multiplied by the clip length the platform produces at the resolution you requested. The following rates were read from the live model pages on August 7, 2026:

Model route	480P	720P	1080P
wan2.2-i2v-plus	$0.0122/sec	$0.0122/sec	$0.0611/sec
wan2.2-i2v-flash	$0.0008/sec	$0.0216/sec	$0.0216/sec

Figure 1: Live pricing section of the wan2.2-i2v-plus model page, captured from the live page on August 7, 2026. Unit is USD per second of generated video, by output resolution.

Two things worth noting before you compare these numbers with anything else. First, a 5-second 720P clip on i2v-plus costs about $0.06, while the same clip on i2v-flash costs about $0.11 — the flash tier is cheaper at 480P and 1080P, but not at 720P, so “which route is cheaper” has no answer without pinning the resolution. Second, Alibaba publishes its own per-second rates on the Model Studio billing pages; the official route and aggregator routes can differ, and only a like-for-like comparison of model, resolution, and clip length means anything. The rates here are a snapshot for integration planning, not a price guarantee — validate against live pages before committing budget.

For a sense of real-world spend: at 480P, the flash route produces a 5-second clip for about $0.004 — cheap enough for high-volume storyboard testing — while the plus route at 1080P costs about $0.31 for the same 5 seconds. That spread is the whole pricing story in miniature: Wan 2.2 I2V is a per-second product with an order-of-magnitude price range depending on which variant and resolution you pin, and the cheapest combination is not the one the model names suggest. Pin resolution and variant in code, then forecast against the rate row that matches, not against the headline model name.

How to call the Wan 2.2 I2V API: submit–poll–retrieve in cURL, Python, and JavaScript

Every hosted Wan 2.2 I2V API follows the same lifecycle. The input is a first-frame image URL and a prompt describing the motion; the output is a task that you poll until it completes.

Figure 2: The submit–poll–retrieve lifecycle of the Wan 2.2 image-to-video API. The image and prompt go in, the platform returns a task id, and the finished video comes out only after the task reaches a terminal state.

The exact request shape varies by provider, but the pattern is identical across Alibaba Cloud Model Studio’s official first-frame API reference and the aggregator routes built on it — Modellix documents the full request and response contract at docs.modellix.ai/ways-to-use/api. In cURL, a submit looks like this:

curl -X POST "https://api.modellix.ai/api/v1/alibaba/wan2.2-i2v-plus/async" \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "img_url": "https://your-cdn.example.com/first-frame.jpg",
    "prompt": "The subject turns slowly toward the camera, soft focus, cinematic lighting",
    "resolution": "720P"
  }'

The response contains a task id rather than a video. Poll it until the status becomes terminal:

curl -s "https://api.modellix.ai/api/v1/tasks/$TASK_ID" \
  -H "Authorization: Bearer ***"

The same lifecycle in Python, with a polling loop, is what you will actually ship:

import time
import requests

API_KEY = "YOUR_MODELLIX_API_KEY"
BASE = "https://api.modellix.ai/api/v1"

def generate_i2v(img_url: str, prompt: str, resolution: str = "720P") -> dict:
    submit = requests.post(
        f"{BASE}/alibaba/wan2.2-i2v-plus/async",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={"img_url": img_url, "prompt": prompt, "resolution": resolution},
        timeout=30,
    )
    submit.raise_for_status()
    task_id = submit.json()["data"]["task_id"]

    while True:
        status = requests.get(
            f"{BASE}/tasks/{task_id}",
            headers={"Authorization": f"Bearer {API_KEY}"},
            timeout=30,
        ).json()
        if status["data"]["status"] in ("success", "failed"):
            return status["data"]
        time.sleep(5)  # poll interval; check the provider docs for rate limits

result = generate_i2v(
    "https://your-cdn.example.com/first-frame.jpg",
    "The subject turns slowly toward the camera, soft focus, cinematic lighting",
)
video_url = result["result"]["resources"][0]["url"] if result["status"] == "success" else None

The img_url field accepts HTTP/HTTPS URLs or base64 data; a publicly reachable first-frame URL is the least error-prone input. If the async contract is new to you, our image-to-video API guide walks through the provider-by-provider differences in lifecycle and polling behavior in more depth.

The same two calls work from JavaScript — here is the equivalent loop in Node.js’s built-in fetch():

const API_KEY = process.env.MODELLIX_API_KEY;
const SUBMIT_URL = "https://api.modellix.ai/api/v1/alibaba/wan2.2-i2v-plus/async";

async function generateI2V(imgUrl, prompt, resolution = "720P") {
  const submit = await fetch(SUBMIT_URL, {
    method: "POST",
    headers: { Authorization: `Bearer ${API_KEY}`, "Content-Type": "application/json" },
    body: JSON.stringify({ img_url: imgUrl, prompt, resolution }),
  });
  const taskId = (await submit.json()).data.task_id;

  while (true) {
    await new Promise((resolve) => setTimeout(resolve, 5000));
    const poll = await (await fetch(
      `https://api.modellix.ai/api/v1/tasks/${taskId}`,
      { headers: { Authorization: `Bearer ${API_KEY}` } }
    )).json();
    if (poll.data.status === "success") return poll.data.result.resources[0].url;
    if (poll.data.status === "failed") throw new Error(poll.data.error);
  }
}

Two additions make this loop production-safe. First, treat every non-2xx response from the submit call as a hard failure and retry with backoff — a transient 429 or 5xx at submission is far cheaper to retry than a task that fails five minutes later. Second, store the full task-status response on every poll: the output URL, the error message if any, and the timestamps. When a video job fails after two minutes of polling, the status payload is the only evidence you have about why, and most providers return a structured error field you can log directly.

Parameters that actually matter

Beyond img_url and prompt, the Wan 2.2 I2V request surface is small. The parameters below are documented on the model page and align with the official reference:

Parameter	Type	Required	What it does
img_url	string	Yes	First-frame image; accepts HTTP/HTTPS URLs or base64
prompt	string	No	Describes the motion and camera movement to add
negative_prompt	string	No	Describes what to avoid in the output
prompt_extend	boolean	No	Automatically expands a short prompt into a fuller one
resolution	string	No	480P, 720P, or 1080P
seed	integer	No	-1 for random; a fixed value for reproducible results

Two practical notes. First, prompt_extend exists because Wan 2.2 quality is prompt-sensitive — the official ecosystem recommends extending prompts before generation, and the model can even generate motion from the image alone if you leave the prompt empty. Second, resolution drives cost directly through the per-second rates in the pricing table, so pin it explicitly in code instead of relying on a platform default that may change.

Common errors and how to debug them

The failure modes of a Wan 2.2 I2V integration are mostly infrastructure, not model behavior:

• Polling forever. Video generation takes tens of seconds to minutes. If your loop never sees a terminal state, check that you are polling the right task id and that your timeout budget covers a full job, not a single request.
• img_url not reachable. The platform fetches your first frame from the URL you provide. A private host, an expiring signed URL, or a redirect that the fetcher does not follow produces a submission error or a failed task. Serve the image from a public URL and test it with a plain curl -I first.
• Resolution not supported. The A14B I2V model’s documented range is 480P–720P; requesting 1080P can fail on routes that do not expose the upscaled tier even though the aggregator catalog lists it. Check the model page’s live parameter enums.
• Rate limits on polling. Polling every second burns quota and can trip per-minute limits. Use the documented poll interval (commonly 5 seconds or more) and back off on non-terminal states.

If a task fails, the provider’s task-status response should include an error message — surface it in your logs rather than collapsing it into a generic “generation failed.”

Wan 2.2 vs Wan 2.7: which image-to-video endpoint should your pipeline call?

This is the decision the top search results skip. Wan 2.2 I2V is a stable, documented, widely mirrored model — which is precisely its argument. If your pipeline has been running it in production for months, the code and pricing in this guide apply unchanged, and there is no emergency to migrate. Legacy compatibility is a feature when the alternative is re-testing outputs and re-validating quality on a new model.

But for a new integration, the comparison is not close. Wan 2.7, covered in our Wan 2.7 API guide, adds thinking-mode prompt planning, native synchronized audio, and clips up to 15 seconds at 1080p under the same Apache 2.0 lineage — and the catalog guidance is explicit that new creations should use Wan 2.7 I2V. If you are evaluating both, run the same first frame and prompt through each model and compare three things: output quality at your target resolution, per-second cost at that resolution, and clip length limits. Our best AI video generation APIs roundup includes this exact kind of batch comparison across the current catalog.

One honest caveat from the platform side: choosing Wan 2.7 means the model pages, pricing, and parameter docs you read today are newer and subject to faster change. Choosing Wan 2.2 means you are on a model the vendor itself labels legacy — support will not improve, and pricing pressure comes only from hosting competition, not from the vendor.

Frequently asked questions about the Wan 2.2 image-to-video API

Do I need a Wan 2.2 image-to-video API key? Yes. Every hosted route — Alibaba Cloud Model Studio, hosting platforms, and aggregators — requires an API key for authentication. On Modellix, one key covers all models in the catalog, so the same key that calls wan2.2-i2v-plus also calls every other image and video model.

Is there a free way to use Wan 2.2 image-to-video? The only genuinely free path is self-hosting the open weights — the model itself costs nothing under Apache 2.0, but you pay for GPU time (roughly 80 GB VRAM for single-GPU A14B inference). Hosted APIs may offer limited free credits at signup; check each platform’s current terms, because credit amounts change frequently and the official Model Studio route and aggregator routes have different policies.

How long does a Wan 2.2 I2V API job take? It depends on resolution, clip length, and the platform’s queue. Expect tens of seconds to a few minutes per job. The API is asynchronous precisely because generation does not fit a synchronous request budget.

What is the difference between Wan 2.2 image-to-video and text-to-video? Image-to-video animates a provided first frame; text-to-video generates the scene from the prompt alone. If you need a specific subject, product, or composition, I2V is the correct call. For the text-first path, see our text-to-video API guide.

Which resolutions does the Wan 2.2 I2V API support? The documented I2V range is 480P and 720P on the A14B model; some routes expose an upscaled 1080P tier at a higher per-second rate. Check the live model page for the current enum.

Should I use Wan 2.2 or Wan 2.7 for image-to-video? For new integrations, Wan 2.7. For existing production pipelines already validated on Wan 2.2, staying on it is defensible — the code and pricing in this guide apply unchanged, and migration should be driven by a measured quality-and-cost comparison, not by version number.

---

Provider details and pricing reflect public information as of August 2026 and change frequently. Validate against each provider’s live pricing before committing. Access image and video models, including the leading Chinese models, through a single API key at modellix.ai.