# Wan v2.2 5B · Image to Video API

> Wan 2.2 5B image-to-video with flexible frame counts, 580p or 720p, and frame interpolation

Animates an image (`image_url`) from a text `prompt`. `num_frames` ranges from 17 to 161 and `frames_per_second` from 4 to 60, at 580p or 720p. Aspect ratio can be auto, 16:9, 9:16 or 1:1. Frame interpolation uses film or rife, adding 0 to 4 frames between each pair, and `video_quality` and `video_write_mode` control encoding.

- Model id: `wan/v2.2-5b/image-to-video`
- Made by: Alibaba
- Category: Image to Video
- Output: video
- Price: $0.15 / video (cheapest run $0.15 (150 API credits))
- Run: `POST https://api.doitong.com/v1/run/wan/v2.2-5b/image-to-video`
- Quote: `POST https://api.doitong.com/v1/quote/wan/v2.2-5b/image-to-video`
- Docs page: https://doitong.com/developers/models/wan/v2.2-5b/image-to-video

## Pricing

Price: **$0.15 / video**. Billed once per generated video.

The full example input below costs $0.15 = 150 API credits (1 video × 150 API credits).

Prices are the upstream price in USD, paid from the API balance in API credits (1000 API credits = 1 USD). `POST https://api.doitong.com/v1/quote/wan/v2.2-5b/image-to-video` with the same JSON body returns the exact price for that input; the quote is exactly what a run charges. Invalid input is never charged and failed or canceled requests are refunded automatically.

## Input parameters

Send either the canonical name or the native field name (not both). Canonical names are the same across models.

| Parameter | Canonical name | Type | Required | Default | Allowed values / range | Description |
|---|---|---|---|---|---|---|
| `image_url` | `image` | string (image URL) | yes |  |  | Source image URL, with the selected aspect ratio determining whether preprocessing is needed: a mismatch triggers resizing followed by a center crop. |
| `prompt` |  | string | yes |  |  | Text instructions that guide video generation. |
| `num_frames` |  | integer | no | `81` | 17 – 161 | Frame count for generation, with an inclusive range of 17–161. |
| `frames_per_second` |  | integer \| null | no | `24` | 4 – 60 | Generated video frame rate, accepting values from 4 to 60; setting `adjust_fps_for_interpolation` to false preserves this rate unchanged. With interpolation in use and `adjust_fps_for_interpolation` true (its default), multiply this rate by one plus the interpolated frame count to obtain the final FPS. For example, 16 FPS with 1 interpolated frame becomes 32 FPS. |
| `negative_prompt` |  | string | no | `` |  | Negative prompt applied when generating a video. |
| `seed` |  | integer \| null | no |  |  | Seed that makes generation reproducible. Setting it to None selects a seed randomly. |
| `resolution` |  | enum (string) | no | `720p` | `580p`, `720p` | Output video resolution, either 580p or 720p. |
| `aspect_ratio` |  | enum (string) | no | `auto` | `auto`, `16:9`, `9:16`, `1:1` | Generated-video proportions, selected automatically from the input image when set to 'auto'. |
| `num_inference_steps` |  | integer | no | `40` | 2 – 50 | Sampling step count, trading longer processing time for better quality as the count increases. |
| `enable_safety_checker` |  | boolean | no | `false` |  | Input safety screening before processing, which only authorized accounts may turn off. Requests lacking authorization are always screened; otherwise, true enables screening. |
| `enable_output_safety_checker` |  | boolean | no | `false` |  | Controls safety screening of the generated video; setting true enables a check after generation. |
| `enable_prompt_expansion` |  | boolean | no | `false` |  | Allow a large language model to enrich the prompt with details. Enabling this expansion leaves the prompt's meaning unchanged. |
| `guidance_scale` |  | number | no | `3.5` | 1 – 10 | Classifier-free guidance strength, trading possible quality loss for closer prompt matching as the scale increases. |
| `shift` |  | number | no | `5` | 1 – 10 | Video shift setting, with an allowed range of 1.0–10.0. |
| `interpolator_model` |  | enum (string) | no | `film` | `none`, `film`, `rife` | Frame interpolation setting: choose None to skip interpolation, or specify the model to perform it. |
| `num_interpolated_frames` |  | integer | no | `0` | 0 – 4 | Insert 0–4 interpolated frames into every gap between two generated frames. |
| `adjust_fps_for_interpolation` |  | boolean | no | `true` |  | Frame-rate adjustment toggle: false preserves the supplied FPS, whereas true scales it by one plus the interpolated frame count. Thus, 16 FPS becomes 32 FPS when 1 frame is interpolated and adjustment is enabled. |
| `video_quality` |  | enum (string) | no | `high` | `low`, `medium`, `high`, `maximum` | Output video quality setting that trades larger files for improved visuals as the setting increases. |
| `video_write_mode` |  | enum (string) | no | `balanced` | `fast`, `balanced`, `small` | Video writing mode, with balanced offering a compromise between speed and quality. Choose small for the smallest files and slowest writing; faster writing returns results sooner but creates larger files. |

File parameters (`image`) take a public `https://` URL, a `data:` URI up to 10 MB, or the `file_url` of an upload from `POST /files`.

## Example input

Required parameters only:

```json
{
  "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
  "image": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg"
}
```

A fuller example:

```json
{
  "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
  "image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg"
}
```

## Run it

Set `DOITONG_API_KEY` to a key from https://doitong.com/developers/dashboard#keys. `?wait=20` returns the finished request in the same call when it is ready within 20 seconds; otherwise poll `GET /requests/{id}` (it also accepts `?wait=`), or pass `webhook_url`.

### curl

```bash
# Run the model; wait up to 20 s for the finished result in the same call
curl -X POST "https://api.doitong.com/v1/run/wan/v2.2-5b/image-to-video?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
    "image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg"
  }'

# Still "queued" or "running"? Poll with the id from the response:
curl "https://api.doitong.com/v1/requests/REQUEST_ID?wait=20" \
  -H "Authorization: Bearer $DOITONG_API_KEY"
```

### JavaScript

```javascript
const API = "https://api.doitong.com/v1";
const headers = {
  "Authorization": "Bearer " + process.env.DOITONG_API_KEY,
  "Content-Type": "application/json",
};

// Run the model; wait up to 20 s for the finished result in the same call
let res = await fetch(API + "/run/wan/v2.2-5b/image-to-video?wait=20", {
  method: "POST",
  headers,
  body: JSON.stringify({
    "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
    "image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg"
  }),
});
let request = await res.json();
if (!res.ok) throw new Error(request.error.code + ": " + request.error.message);

// Not finished yet: long-poll until it is
while (request.status === "queued" || request.status === "running") {
  res = await fetch(API + "/requests/" + request.id + "?wait=20", { headers });
  request = await res.json();
}
if (request.status !== "succeeded") throw new Error(JSON.stringify(request.error));
console.log(request.outputs.map((o) => o.url), request.cost.credits + " API credits ($" + request.cost.usd + ")");
```

### Python

```python
import os
import requests

API = "https://api.doitong.com/v1"
headers = {"Authorization": "Bearer " + os.environ["DOITONG_API_KEY"]}

payload = {
    "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
    "image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg",
}

# Run the model; wait up to 20 s for the finished result in the same call
r = requests.post(API + "/run/wan/v2.2-5b/image-to-video", params={"wait": 20}, json=payload, headers=headers)
request = r.json()
if not r.ok:
    raise RuntimeError(request["error"]["code"] + ": " + request["error"]["message"])

# Not finished yet: long-poll until it is
while request["status"] in ("queued", "running"):
    request = requests.get(API + "/requests/" + request["id"], params={"wait": 20}, headers=headers).json()
if request["status"] != "succeeded":
    raise RuntimeError(request["error"])
print([o["url"] for o in request["outputs"]], request["cost"]["credits"], "API credits", "$" + request["cost"]["usd"])
```

### MCP

The MCP server at `https://api.doitong.com/v1/mcp` exposes the tools `search_models`, `get_model`, `quote`, `run`, `get_request`, `cancel_request`, `list_requests`, `create_upload` and `get_account`. A `run` call for this model:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "run",
    "arguments": {
      "model_id": "wan/v2.2-5b/image-to-video",
      "input": {
        "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
        "image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg"
      },
      "wait_seconds": 20
    }
  }
}
```

## Response

Every call returns a request object. `status` is one of `queued`, `running`, `succeeded`, `failed`, `canceled`. `outputs` lists the generated files with URLs on our storage (kept forever, or 7 days with `?storage=temporary`; `storage` says which); `output` is the model's own result object with the same URLs.

```json
{
  "id": "req_8k2m4q7x1z9c3v5b6n0p2r4t",
  "object": "request",
  "model": "wan/v2.2-5b/image-to-video",
  "status": "succeeded",
  "created_at": "2026-10-20T12:00:00Z",
  "started_at": "2026-10-20T12:00:02Z",
  "completed_at": "2026-10-20T12:00:09Z",
  "queue_position": null,
  "cost": {
    "credits": 150,
    "usd": "0.15",
    "charged": 150,
    "refunded": 0
  },
  "input": {
    "prompt": "A red fox trots through fresh snow at sunrise, soft golden light, shallow depth of field",
    "image_url": "https://content.doitong.com/images/showcase/v3/gen_fox_cartoon.jpg"
  },
  "output": {
    "video": {
      "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.mp4",
      "content_type": "video/mp4",
      "file_name": "0-output.mp4",
      "file_size": 1843200
    },
    "prompt": "The white dragon warrior stands still, eyes full of determination and strength. The camera slowly moves closer or circles around the warrior, highlighting the powerful presence and heroic spirit of the character.",
    "seed": 42
  },
  "outputs": [
    {
      "type": "video",
      "url": "https://content.doitong.com/dev-api/2026/10/20/req_8k2m4q7x1z9c3v5b6n0p2r4t/0-output.mp4",
      "content_type": "video/mp4",
      "file_size": 1843200,
      "width": 1280,
      "height": 720,
      "duration": 5,
      "stored": true
    }
  ],
  "error": null,
  "metrics": {
    "inference_seconds": 6.8
  },
  "urls": {
    "self": "https://api.doitong.com/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t",
    "cancel": "https://api.doitong.com/v1/requests/req_8k2m4q7x1z9c3v5b6n0p2r4t/cancel"
  }
}
```

### Output fields (`output`)

| Field | Type | Description |
|---|---|---|
| `video` | object {url, content_type, file_name, file_size} | Video file produced by generation. |
| `prompt` | string | Text prompt used to generate the video. |
| `seed` | integer | Seed value applied during generation. |

## Related models

- [Wan · v2.2 5b · Text to Image](https://doitong.com/developers/models/wan/v2.2-5b/text-to-image.md) (`wan/v2.2-5b/text-to-image`): $0.016 / image
- [Wan v2.2 5B · Text to Video](https://doitong.com/developers/models/wan/v2.2-5b/text-to-video.md) (`wan/v2.2-5b/text-to-video`): $0.15 / video
- [Wan · v2.2 5b · Text to Video · Distill](https://doitong.com/developers/models/wan/v2.2-5b/text-to-video/distill.md) (`wan/v2.2-5b/text-to-video/distill`): $0.08 / video
- [Wan 3.0 Image to Video](https://doitong.com/developers/models/alibaba/wan-3.0/image-to-video.md) (`alibaba/wan-3.0/image-to-video`): from $0.05 / second
- [FLUX 3 Max Image to Video](https://doitong.com/developers/models/blackforestlabs/flux-3-max/image-to-video.md) (`blackforestlabs/flux-3-max/image-to-video`): from $0.0425 / second of output video
- [Grok Imagine Video 1.5 Image to Video](https://doitong.com/developers/models/xai/grok-imagine-video/v1.5/image-to-video.md) (`xai/grok-imagine-video/v1.5/image-to-video`): from $0.082 / second
- [Kling 3.0 Pro Image to Video](https://doitong.com/developers/models/kling-video/v3/pro/image-to-video.md) (`kling-video/v3/pro/image-to-video`): from $0.112 / second
- [LTX 2.5 Pro Image to Video](https://doitong.com/developers/models/lightricks/ltx-2.5/image-to-video/pro.md) (`lightricks/ltx-2.5/image-to-video/pro`): from $0.12 / second

## Links

- HTML page: https://doitong.com/developers/models/wan/v2.2-5b/image-to-video
- All models and guides for AI agents: https://doitong.com/developers/llms.txt
- OpenAPI 3.1 with this model's typed request body: https://doitong.com/developers/openapi.json?model=wan/v2.2-5b/image-to-video
- Errors: https://doitong.com/developers/docs/errors
- Model details as JSON: https://api.doitong.com/v1/models/wan/v2.2-5b/image-to-video