Name: Alibaba Wan 2.7 Image Generation and Editing API
Brand: magicapi
SKU: api-magicapi-image-generation-editing-wan-video-wan-2-7-image
Availability: InStock
Author: API Market

Shashank Agarwal

# 🖼️ Image Generation and Editing API (Alibaba Wan 2.7 Image)

## Overview
Wan 2.7 Image is Alibaba's image model for text-to-image generation and image editing. It generates images up to 2048 pixels on the long side, edits up to 9 input images, and has a thinking mode and an image set mode.

Send a text `prompt` to generate images. Add up to 9 input `images` to switch to editing, style transfer or multi-reference generation. Each request returns a list of image URLs, one per output image.

## Features
- **Text-to-image and editing in one endpoint**: with no `images` the model generates from the prompt; with `images` it edits or combines them.
- **Sizes up to 2K**: `size` accepts `1K` or `2K` (default), which auto-size, or an exact size such as `2048*1152` or `1152*2048`.
- **Thinking mode**: `thinking_mode` (default `true`) enables enhanced reasoning for text-to-image requests. It does not apply when you send `images` or use `image_set_mode`, and it increases generation time.
- **Image sets**: `image_set_mode` generates a coherent set of related images from one prompt, for example one character across seasons.
- **Several outputs**: `num_outputs` returns 1 to 4 images per request.
- **Seed**: set a seed (0 to 2147483647) to reproduce a result.

## Use Cases
1. **Illustrations and scenes**: interiors, landscapes and lifestyle images from a text description.
2. **Image editing**: change, restyle or combine photos by sending them as `images` with an editing prompt.
3. **Character and story sets**: a consistent subject across several scenes with `image_set_mode`.
4. **Social and web formats**: square, landscape and portrait images with sizes such as `1024*1024`, `1280*720` or `720*1280`.

## Visual Examples
### Example Input
Prompt: "A cozy bookshop interior with warm golden light streaming through tall windows, floor-to-ceiling shelves packed with colorful books, a tabby cat sleeping on a stack of novels, steam rising from a cup of tea on a reading desk"

Settings: `size` `2K`, `seed` `7777`. All other fields were left at their defaults (no input images, `thinking_mode` `true`, one output).

### Example Output
![Wan 2.7 Image output: a cozy bookshop with tall windows, full shelves, a tabby cat asleep on a stack of books and a steaming cup of tea](https://blog.api.market/wp-content/uploads/2026/11/wan-2-7-image-output-bx2s31fs-api-market.jpg)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Text prompt for image generation or editing |
| `images` | array of strings (URLs) | No | `[]` |  | Input images for editing, style transfer, or multi-reference generation (up to 9 images, jpg/png/bmp/webp). When provided, the model operates in image editing mode |
| `size` | string | No | `2K` | `1K`, `2K`, `1024*1024`, `2048*2048`, `1280*720`, `720*1280`, `2048*1152`, `1152*2048`, `1024*768`, `768*1024`, `2048*1536`, `1536*2048` | Output image resolution. `1K` and `2K` auto-size based on input images |
| `num_outputs` | integer | No | `1` | 1 to 4 | Number of images to generate |
| `image_set_mode` | boolean | No | `false` |  | Generate a coherent set of related images from a single prompt (e.g. a character across seasons) |
| `thinking_mode` | boolean | No | `true` |  | Enable enhanced reasoning for improved image quality. Only applies to text-to-image (no input images, no image set mode). Increases generation time |
| `seed` | integer | No | none |  | Random seed for reproducible generation. Range: 0-2147483647 |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.036 per API unit.
- **1 API unit = 1 output image.** A request returns `num_outputs` images (1 by default, up to 4), so a request costs $0.036 per image returned: $0.036 for 1 image, $0.144 for 4.
- Every `size`, `thinking_mode` and editing request is billed the same per image.
- **Example cost**: the example request returned 1 image, so it cost $0.036.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/image-generation-editing-wan-video-wan-2-7-image`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well. The example took about 36 seconds.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/image-generation-editing-wan-video-wan-2-7-image/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "wan-video/wan-2.7-image",
    "input": {
      "seed": 7777,
      "size": "2K",
      "prompt": "A cozy bookshop interior with warm golden light streaming through tall windows, floor-to-ceiling shelves packed with colorful books, a tabby cat sleeping on a stack of novels, steam rising from a cup of tea on a reading desk"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "bx2s31fssxrmw0d1mvptypawvr",
  "version": "wan-video/wan-2.7-image",
  "status": "starting",
  "created_at": "2026-11-04T14:19:36.271Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/image-generation-editing-wan-video-wan-2-7-image/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "bx2s31fssxrmw0d1mvptypawvr",
  "status": "succeeded",
  "output": [
    "https://blog.api.market/wp-content/uploads/2026/11/wan-2-7-image-output-bx2s31fs-api-market.jpg"
  ],
  "error": null,
  "created_at": "2026-11-04T14:19:36.271Z",
  "started_at": "2026-11-04T14:19:36.284Z",
  "completed_at": "2026-11-04T14:20:12.135Z"
}
```

`output` is a list of image URLs, one per generated image.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `prompt`, a `size` that is not in the list or `num_outputs` above 4.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
Requests are rate limited to keep usage fair. If you receive a 429 response, wait and retry with exponential backoff.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/image-generation-editing-wan-video-wan-2-7-image";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "wan-video/wan-2.7-image", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 1000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

createAndWaitForPrediction({
  "seed": 7777,
  "size": "2K",
  "prompt": "A cozy bookshop interior with warm golden light streaming through tall windows, floor-to-ceiling shelves packed with colorful books, a tabby cat sleeping on a stack of novels, steam rising from a cup of tea on a reading desk"
}).then((output) => console.log(output));
```

#### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/image-generation-editing-wan-video-wan-2-7-image"


def create_and_wait_for_prediction(input_data):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "wan-video/wan-2.7-image", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])


def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 1
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 10 minutes")


print(create_and_wait_for_prediction({
    "seed": 7777,
    "size": "2K",
    "prompt": "A cozy bookshop interior with warm golden light streaming through tall windows, floor-to-ceiling shelves packed with colorful books, a tabby cat sleeping on a stack of novels, steam rising from a cup of tea on a reading desk"
}))
```

## FAQ
- **How do I edit an image instead of generating one?**
  - Send one or more image URLs (up to 9) in `images` and describe the change in `prompt`. The model then works in editing mode, and `thinking_mode` no longer applies.
- **What is the largest output size?**
  - 2048 pixels on the long side, for example `2048*2048` or `2048*1152`. This model has no 4K option.
- **How many images does one request return?**
  - `num_outputs` images, 1 by default and up to 4. Each is billed as one API unit ($0.036).
- **How do I make generation faster?**
  - `thinking_mode` is on by default for text-to-image and increases generation time. Set it to `false` to turn it off.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## Contact Us
If you have any questions, reach out to us through the chat on the bottom right of the page.


Generate images from text at up to 2K with an optional thinking mode, or edit and combine up to 9 images, with Alibaba's Wan 2.7 Image. $0.036 per image, pay as you go.