# Wan 2.7 Image Pro

> Run Wan 2.7 Image Pro by alibaba online or via API. $0.075/image, no setup.

**URL:** https://inference.sh/apps/alibaba/wan-2-7-image-pro
**Last updated:** 2026-10-30

---

Wan 2.7 Image Pro is Alibaba's professional image generation model supporting text-to-image, image editing, and multi-reference generation with up to 4K high-definition output

- app: `alibaba/wan-2-7-image-pro`
- maker: [alibaba](https://inference.sh/apps/alibaba.md)
- category: [image](https://inference.sh/apps/category/image.md)
- input → output: text → image
- tasks: [text to image](https://inference.sh/apps/tag/text-to-image.md), [image editing](https://inference.sh/apps/tag/image-editing.md)
- price: $0.075/image
- runs via: api, javascript and python sdk, belt cli, mcp

Alibaba's Tongyi Lab has been building image generation models for years, mostly for their own ecosystem. Wan 2.7 Image - released in April 2026 as the latest major upgrade to the Wanxiang series - is what happens when that internal investment gets packaged for external consumption. Available on [inference shell](https://inference.sh) in both standard and Pro variants, it occupies an interesting middle ground in the current market - cheaper than the premium models that dominate conversations, more capable than the budget options that cut too many corners. The pricing sits in a tier that forces you to actually evaluate the output rather than dismissing it on cost alone.

I have spent time with both variants, and my take is nuanced. Wan 2.7 is genuinely good at certain things - Asian aesthetics, detailed photography-style compositions, scenes with lots of visual information - and mediocre at others. It is not a universal replacement for anything. But for specific workflows, particularly those involving cultural content, product photography, and high-density visual scenes, it produces output that surprised me.

## the two-tier system explained

The standard Wan 2.7 Image model outputs up to 2K resolution (2048x2048). The Pro variant pushes output to 4K resolution (up to 4096x4096) at a higher price point. Both share the same input interface - text prompt, optional reference images, thinking mode, batch generation up to four images. The difference is purely in output fidelity and the internal model capacity dedicated to each generation.

This is a sensible split. Most use cases do not require 4K output. Social media posts, web assets, design explorations, content illustrations - these live at 1K or 2K comfortably. You only need Pro when the final output will be viewed at large scale or when you need the additional coherence that comes with a more computationally intensive generation pass. I find myself using standard for 80% of work and switching to Pro only when I know the result needs to survive close inspection.

In terms of positioning, Wan standard sits between the budget tier and the premium tier, while Wan Pro competes directly with mid-range options from Google and OpenAI.


## where wan 2.7 genuinely excels

Every model has a signature strength, and Wan 2.7's is visual density. Give it a prompt describing a crowded market scene, a detailed interior with lots of objects, or a landscape packed with visual information, and it handles the complexity with unusual grace. Where FLUX Dev might simplify or smear background elements, Wan 2.7 tends to render them with individual attention. This is not a subtle difference - in scenes with ten or more distinct objects, the gap is noticeable.

The model also shows clear strength with East Asian visual aesthetics. Traditional architecture, calligraphy-influenced compositions, ink wash painting styles, scenes involving Chinese or Japanese cultural elements - these feel native rather than approximated. I suspect the training data heavily represented this content, and it shows. If your work involves Asian markets, cultural content, or any aesthetic that draws from that tradition, Wan 2.7 should be on your shortlist regardless of what else you are using.

Another standout feature is precise color control - the model accepts HEX codes and color palette specifications for brand-accurate visuals. If you need output that matches a specific brand color system, you can specify exact values rather than hoping the model interprets "corporate blue" the way you intend.

Photography-style output is another area where the model punches above its price point. Prompts that specify camera characteristics, lighting setups, and photographic techniques get interpreted with sophistication. Asking for "overhead flat lay product photography, soft diffused lighting, white marble surface" produces results that look like they came from a product shoot rather than a generation pipeline. The model understands depth of field, bokeh characteristics, and the way different lens lengths compress perspective.

## thinking mode and what it actually does

Both variants support a thinking mode toggle that enables internal reasoning before generation begins. This is not marketing fluff - it produces measurably different results on complex prompts. When you have a prompt describing multiple subjects with specific spatial relationships, color requirements, and stylistic constraints, thinking mode helps the model plan the composition before committing pixels.

The tradeoff is generation time. Thinking mode adds latency, and on prompts that are already simple and direct, it adds nothing of value. I use it selectively: for prompts with four or more distinct elements that need to coexist in specific arrangements, or when I have tried a prompt without thinking mode and gotten confused compositions. For single-subject prompts or straightforward scene descriptions, skip it.

## reference images and editing workflows

Both models accept up to nine reference images, which opens up editing and guided generation workflows that pure text-to-image models cannot touch. You can provide a product photo and ask for it placed in a lifestyle context. You can supply style reference images and get generations that match that visual language. You can pass in multiple reference angles of a subject and generate new views.

This capability puts Wan 2.7 in a different category from FLUX Dev, which has no reference image support at all. It competes more directly with GPT Image 2's editing mode and Gemini Flash's image understanding, though the interface is different. Rather than masking and inpainting, Wan 2.7 treats references as compositional guidance - it synthesizes new images informed by the references rather than surgically modifying existing ones.

The reference system works best when you provide clear, well-lit source images and pair them with prompts that explicitly describe what you want done with those references. Vague prompts with reference images produce unpredictable results. Specific prompts with good references produce surprisingly controlled output.


## prompt tips that actually matter

After generating several hundred images across both variants, I have opinions about what works.

Be specific about lighting. Wan 2.7 responds strongly to lighting descriptions - "golden hour side lighting," "overhead fluorescent," "single point source from upper left" all produce distinctly different results. Generic prompts without lighting information tend to default to flat, even illumination that looks stock-photo-ish.

Front-load the subject. The model weights earlier tokens more heavily than later ones. Put your main subject and its key characteristics in the first clause, then add environmental and stylistic details after. "A weathered fishing boat with peeling blue paint, docked at a misty morning harbor, shot from water level" works better than burying the boat description after paragraphs of atmosphere.

Use photography terminology when you want photorealistic output. Specifying "shot on 85mm f/1.4" or "wide angle lens distortion" or "macro photography, 1:1 magnification" gives the model concrete visual parameters to work with rather than leaving it to guess what "photorealistic" means in context.

For the Pro model specifically, detail your texture expectations. Pro has the resolution to render fine textures meaningfully, so prompts that mention "visible fabric weave," "individual hair strands," or "water droplet surface tension" get rewarded with corresponding detail. The standard model will attempt these but cannot resolve them at 2K the way Pro does at 4K.

Avoid prompt overloading. Both models handle complex prompts better than most competitors, but there is still a point where adding more descriptors starts contradicting earlier ones. I try to keep prompts under 100 words and use thinking mode instead of prompt length to handle complexity.

## honest comparison with the competition

Against FLUX Dev: FLUX Dev wins decisively on cost and is perfectly adequate for simple, single-subject generations. Wan 2.7 standard costs more but produces noticeably better results on complex scenes, handles reference images, and offers thinking mode. If your workflow is bulk generation of straightforward images, FLUX Dev remains the rational choice. If you need more sophisticated compositions or editing capabilities, the price premium buys real capability.

Against Gemini Flash Image: Similar price tier to Wan Pro. Both models handle text rendering competently - Wan 2.7 supports 12 languages natively, while Gemini brings Google's search grounding for factual accuracy in generated scenes. Wan Pro counters with higher base resolution (4K vs Gemini's output), stronger performance on dense visual scenes, and better handling of non-Western aesthetics. Gemini is more versatile; Wan Pro is more precise in its areas of strength.

Against GPT Image 2: At comparable price points, GPT Image 2 produces more universally polished output. Wan 2.7's text rendering in 12 languages is competitive, though GPT Image 2 still edges ahead on English typography consistency. Wan 2.7 offers better value on batch generation (four images per request at the same per-image cost), superior performance on Asian aesthetic content, and the reference image system gives it editing flexibility that GPT Image 2's approach does not match. For volume work with Asian aesthetics or reference-driven generation, Wan 2.7 is the better tool.


## what it cannot do

Text rendering is actually one of Wan 2.7's strengths - a significant departure from earlier versions. The model supports long-text rendering across 12 languages, handling signs, labels, tables, and even formulas with solid accuracy. It handles prompts of over 3,000 tokens, which means detailed typographic instructions get parsed rather than truncated. For signage, posters, and labeled diagrams, Wan 2.7 is a legitimate option alongside Qwen Image 2 Pro. Where it still falls short compared to Qwen is in the most complex information-design layouts - dense multi-section infographics with hierarchical typography.

The model does not support inpainting or masked editing. Reference images guide new generations rather than surgically modifying existing ones. If you need to change one element of an existing image while preserving everything else, Wan 2.7 is the wrong tool.

Consistency across multiple generations of the same character or subject is not guaranteed, even with seed locking. You can get close by combining seed control with detailed descriptions and reference images, but true character consistency for sequential storytelling requires purpose-built solutions that Wan 2.7 does not provide.

Generation speed on the Pro model is slower than competitors at similar price points. The 4K output takes time to render, and thinking mode adds further latency. For interactive applications where users are waiting, the standard model with thinking mode disabled provides the most responsive experience.

## when to choose wan 2.7

The decision tree is straightforward. Choose Wan 2.7 standard when you need better quality than FLUX Dev provides, your content involves complex scenes or Asian aesthetics, and you want reference image capability without paying premium prices. Choose Pro when the output needs to survive scrutiny at large display sizes or print, or when you need maximum detail fidelity and can tolerate the additional cost and latency.

Do not choose either variant if you need character consistency across a narrative sequence, or if your use case is simple enough that FLUX Dev handles it adequately. Paying six times more for output that looks the same on a social media thumbnail is waste, not quality.

The sequential image set feature deserves mention for specific workflows. Enabling it produces coordinated sets of related images - useful for storyboard creation, product photography series, or any application where you need visual coherence across a batch. Combined with reference images, this creates a lightweight production pipeline for visual content that would otherwise require manual coordination across multiple generation passes.

### is wan 2.7 image better than flux dev?

Not universally, no. FLUX Dev remains the better choice for high-volume, straightforward generation where cost efficiency is the primary concern. Wan 2.7 is better at complex multi-element scenes, reference-based generation, and content with East Asian visual aesthetics. The two models serve different positions in a generation pipeline - FLUX Dev for cheap exploration and simple assets, Wan 2.7 for compositions that demand more visual intelligence. The significant price difference means you should only reach for Wan 2.7 when you genuinely need what it offers beyond FLUX Dev's capabilities.

### should I use standard or pro?

Use standard for anything destined for screens at normal viewing distance - web content, social media, email campaigns, design mockups. Switch to Pro when output will be displayed at large physical sizes, printed, or scrutinized closely by art directors. The per-image difference between standard and Pro is meaningful at volume, so defaulting to standard and upgrading selectively keeps costs rational. Pro's 4K output is genuinely impressive for photography-style content, but that resolution is wasted on a 400-pixel-wide blog thumbnail.

### how does thinking mode affect quality?

Thinking mode makes a real difference on prompts with four or more distinct elements that need specific spatial arrangements. For a prompt like "three people at a dinner table, one standing, candles between them, window behind showing rain" - thinking mode helps the model plan the composition logically before generating. On simple prompts like "a red car on a highway" it adds latency without visible improvement. I recommend leaving it off by default and enabling it when you notice compositional confusion in outputs, or when your prompt reads like a paragraph rather than a phrase.


## wan-2-7-image-pro API Guide

### About
wan 2.7 image pro is alibaba's professional image generation model supporting text-to-image, image editing, and multi-reference generation with up to 4k high-definition output

### Get an API Key
Create one in [settings → api keys](https://app.inference.sh/settings/keys). The examples read it from `INFERENCE_API_KEY`.

```bash
export INFERENCE_API_KEY="inf_your_key"
```

### 1. Calling the API

#### Install the Client

```bash
pip install inferencesh
```

#### Run and Get Result
Submit a request and wait for the final result.

```python
import os
from inferencesh import inference

client = inference(api_key=os.environ["INFERENCE_API_KEY"])

## version @4dfb50pg pinned
result = client.run({
        "app": "alibaba/wan-2-7-image-pro@4dfb50pg",
        "input": {
            "prompt": "prompt"
        }
    })

print(result["output"])
```

#### Stream Live Updates
Get real-time progress updates as the task runs.

```python
import os
from inferencesh import inference

client = inference(api_key=os.environ["INFERENCE_API_KEY"])

## version @4dfb50pg pinned
## stream=True yields updates as they arrive
for update in client.run({
        "app": "alibaba/wan-2-7-image-pro@4dfb50pg",
        "input": {
            "prompt": "prompt"
        }
    }, stream=True):
    if update.get("progress"):
        print(f"progress: {update['progress']}%")
    if update.get("output"):
        print(f"output: {update['output']}")
```

#### Run in the Background
Start the task and get its id back right away, then check on it with `GET /tasks/{id}`. It is done when `status` is 10 (completed), 11 (failed) or 12 (cancelled).

```python
import os
from inferencesh import inference, TaskStatus

client = inference(api_key=os.environ["INFERENCE_API_KEY"])

## returns as soon as the task is created
task = client.run({
        "app": "alibaba/wan-2-7-image-pro@4dfb50pg",
        "input": {
            "prompt": "prompt"
        }
    }, wait=False)

## later: read its current state
state = client.tasks.get(task["id"]).data
if state["status"] == TaskStatus.COMPLETED:
    print(state["output"])
```

### 2. Files

#### Automatic Upload

```python
## local file paths are automatically uploaded
result = client.run({
    "app": "alibaba/wan-2-7-image-pro@4dfb50pg",
    "input": {
        "image": "/path/to/local/image.png",  # detected & uploaded
        "audio": "https://example.com/audio.mp3",  # url passed through
    }
})
```

#### Manual Upload

```python
## upload and get a hosted URL
file = client.files.upload("/path/to/file.png")
print(file.uri)  # https://cloud.inference.sh/...
```

### 3. Schema

#### Input
- **prompt** (string) *required*: Text prompt describing what to generate or edit. Supports Chinese and English, up to 5000 characters. For editing, provide reference images.
- **reference_images** (array): Reference images for editing (0-9 images). Order in array defines image order.
- **num_images** (integer): Number of images to generate (1-4). When image set mode is enabled, max is 12.
- **size** (string): Output resolution: '1K' (1024x1024), '2K' (2048x2048, default), '4K' (4096x4096, text-to-image only). Or specify pixel dimensions like '1024*768'.
- **watermark** (boolean): Add 'AI Generated' watermark to bottom-right corner.
- **thinking_mode** (boolean): Enable thinking mode for better quality. Only effective for text-to-image without image input or image set mode.
- **enable_sequential** (boolean): Enable image set output mode for generating consistent multi-image sets (e.g., same character in different scenes).
- **seed** (integer): Random seed for reproducibility (0-2147483647). Same seed yields similar outputs.

#### Output
- **images** (array): Generated images in PNG format.

## other image apps

- [Gemini Nano Banana 2.1](https://inference.sh/apps/google/gemini-nano-banana-2-1.md): $1.50/M input, $0.0336–$0.1134/image (1K–4K), +$0.014/query Google Search
- [Grok Imagine Image 2.0](https://inference.sh/apps/xai/grok-imagine-image-2-0.md): $0.04/img low 1k, $0.06/img low 2k, $0.06/img med 1k, $0.08/img med 2k; $0.01/source img (edits)
- [GPT Image 2.5 Sunburst](https://inference.sh/apps/openai/gpt-image-2-5-sunburst.md): $0.006-$0.21 per 1024x1024 image: low $0.006, medium $0.013, high $0.053, xhigh $0.094, max $0.21. Larger sizes cost more; edits add ~$0.008 per reference image.
- [GPT Image 2.5 Flare](https://inference.sh/apps/openai/gpt-image-2-5-flare.md): $0.006-$0.21/image at 1024x1024: low $0.0059, medium $0.0132, high $0.0527, xhigh $0.0937, max $0.2107. Larger sizes cost more; edits add ~$0.0083 per reference image.
- [Image Resize & Crop](https://inference.sh/apps/eval/resize.md): from $0.00000277/sec

## faq

### how much does Wan 2.7 Image Pro cost?

$0.075/image. you pay per run from your inference shell credits. no subscription is required.

### how do I run Wan 2.7 Image Pro via api?

call alibaba/wan-2-7-image-pro with the javascript or python sdk, the rest api, or `belt app run alibaba/wan-2-7-image-pro` from a terminal. the api reference on this page lists every input.

### who makes Wan 2.7 Image Pro?

Wan 2.7 Image Pro is made by alibaba and runs on inference shell. every alibaba app is listed at https://inference.sh/apps/alibaba.

### can my agent use Wan 2.7 Image Pro?

yes. agents call it as a tool through the inference shell mcp server (https://api.inference.sh/mcp), the belt cli or the sdk, and pay per run like you do.

### what are the alternatives to Wan 2.7 Image Pro?

other image apps on inference shell include Gemini Nano Banana 2.1, Grok Imagine Image 2.0, GPT Image 2.5 Sunburst, GPT Image 2.5 Flare. they run through the same api, so switching is a one-line change.