Name: Alibaba Wan 2.7 Image Pro Image Generation and Editing API
Brand: magicapi
SKU: api-magicapi-high-quality-image-editing-4k-output-wan-video-wan-2-7-image-pro
Availability: InStock
Author: API Market

Shashank Agarwal

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

## Overview
Wan 2.7 Image Pro is Alibaba's image model for text-to-image generation and image editing. Its developer describes it as producing high-quality images with 4K output, a thinking mode, multi-image editing and image set generation.

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.
- **Up to 4K output**: `size` accepts `1K`, `2K` (default) and `4K`, which auto-size, or an exact size such as `4096*2304`. 4K is only available for text-to-image.
- **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. **Product and macro photography**: detailed close-up images at 2K or 4K.
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. **Wide and tall formats**: banners and posters with exact sizes such as `4096*2304` or `2304*4096`.

## Visual Examples
### Example Input
Prompt: "An extreme close-up macro photograph of a honeybee collecting pollen from a lavender flower, every hair and wing vein sharply detailed, soft bokeh background with morning dew drops glistening on purple petals, natural golden hour lighting, 100mm macro lens"

Settings: `size` `2K`, `thinking_mode` `true`, `seed` `3333`. No input images, so this is a text-to-image request.

### Example Output
![Wan 2.7 Image Pro output: macro photo of a honeybee collecting pollen from a lavender flower with dew drops and a soft bokeh background](https://blog.api.market/wp-content/uploads/2026/11/wan-2-7-image-pro-output-a2byk2yj-api-market.png)

## 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`, `4K`, `1024*1024`, `2048*2048`, `4096*4096`, `1280*720`, `720*1280`, `2048*1152`, `1152*2048`, `4096*2304`, `2304*4096`, `1024*768`, `768*1024`, `2048*1536`, `1536*2048`, `4096*3072`, `3072*4096` | Output image resolution. `1K`, `2K` and `4K` auto-size based on input images. 4K is only available for text-to-image |
| `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` (including 4K), `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/high-quality-image-editing-4k-output-wan-video-wan-2-7-image-pro`

### 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 59 seconds with `thinking_mode` on.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/high-quality-image-editing-4k-output-wan-video-wan-2-7-image-pro/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "wan-video/wan-2.7-image-pro",
    "input": {
      "seed": 3333,
      "size": "2K",
      "prompt": "An extreme close-up macro photograph of a honeybee collecting pollen from a lavender flower, every hair and wing vein sharply detailed, soft bokeh background with morning dew drops glistening on purple petals, natural golden hour lighting, 100mm macro lens",
      "thinking_mode": true
    }
  }'
```

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

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

Response when the prediction has finished (200 OK):
```json
{
  "id": "a2byk2yjzsrmw0d1mvq8tzstjm",
  "status": "succeeded",
  "output": [
    "https://blog.api.market/wp-content/uploads/2026/11/wan-2-7-image-pro-output-a2byk2yj-api-market.png"
  ],
  "error": null,
  "created_at": "2026-11-04T14:20:31.870Z",
  "started_at": "2026-11-04T14:20:31.884Z",
  "completed_at": "2026-11-04T14:21:31.059Z"
}
```

`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/high-quality-image-editing-4k-output-wan-video-wan-2-7-image-pro";

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-pro", 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": 3333,
  "size": "2K",
  "prompt": "An extreme close-up macro photograph of a honeybee collecting pollen from a lavender flower, every hair and wing vein sharply detailed, soft bokeh background with morning dew drops glistening on purple petals, natural golden hour lighting, 100mm macro lens",
  "thinking_mode": true
}).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/high-quality-image-editing-4k-output-wan-video-wan-2-7-image-pro"


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-pro", "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": 3333,
    "size": "2K",
    "prompt": "An extreme close-up macro photograph of a honeybee collecting pollen from a lavender flower, every hair and wing vein sharply detailed, soft bokeh background with morning dew drops glistening on purple petals, natural golden hour lighting, 100mm macro lens",
    "thinking_mode": True
}))
```

## 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. `thinking_mode` and `4K` only apply to text-to-image.
- **Does 4K cost more?**
  - No. Every image costs $0.036 whatever the `size`.
- **How many images does one request return?**
  - `num_outputs` images, 1 by default and up to 4. Each is billed as one API unit.
- **Why does a request take close to a minute?**
  - `thinking_mode` is on by default for text-to-image and increases generation time. The example took about 59 seconds. Set it to `false` for faster results.
- **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 4K with an optional thinking mode, or edit and combine up to 9 images, with Alibaba's Wan 2.7 Image Pro. $0.036 per image, pay as you go.