Qwen-Image-2.1: Local Image Generation Cost

For a hosted workflow, Alibaba Cloud Model Studio provides qwen-image-2.1-turbo and qwen-image-2.1-pro. Both accept text and image input and return images. Their model pages list original API prices, excluding limited-time promotions.

In Singapore (international scope), Turbo is $0.016 per image and Pro is $0.04. In Beijing and the listed global regions—Virginia, Frankfurt, Tokyo and Hong Kong—the pages show $0.014133 and $0.035333 respectively. At Singapore rates, 1,000 images cost $16 with Turbo or $40 with Pro. In the other listed regions the corresponding totals are $14.133 and $35.333. Use the endpoint and billing scope for your account; do not treat a regional quote as a worldwide price.

The downloadable Turbo checkpoint is Qwen/Qwen-Image-2.1-Turbo. Its saved sampling schedule uses eight steps with CFG 1; changing num_inference_steps alone does not replace that saved schedule. The model card gives generation and editing examples and the supported aspect-ratio presets. This is a distinct checkpoint from the base model’s 40-step examples.

Turbo weights use the Qwen Research License Agreement. Downloadable weights do not establish unrestricted commercial permission; review the exact checkpoint license before incorporating the weights into a commercial workflow. Hosted API use follows the service terms.

Laxmi Kant Tiwari published a single-RTX-5090 test with Diffusers on Windows, seed 11 and 40 steps. Both the transformer and encoder were quantized; the VAE kept its original precision. All weights stayed on the GPU with no CPU offload, and there was no BF16 baseline.

The two-reference edit reached 25.6 GB peak in FP8 and 19.1 GB in NF4. These are 32 GB-card measurements, not a verified 24 GB-card result. Reference editing needs more memory than the same-size text-to-image run.

TheTechnoX separately reported a ComfyUI run on a 16 GB RTX 4060 Ti, using INT8 ConvRot image weights, an INT8 Qwen3-VL encoder and BF16 VAE without CPU or disk offload. The author reported roughly 20 seconds for generation and about a minute for editing, but did not specify resolution or steps. Use the post’s examples to judge the task and keep those missing settings out of a timing comparison.

The exact checkpoint is Qwen/Qwen-Image-2.1. Its visual generator has about 7B parameters, with a separate vision-language encoder and VAE in the pipeline. That 7B figure describes the generator, so it is not enough to estimate the memory needed by the whole application.

The official Diffusers examples use 40 steps and recommend 2048×2048 for square images, with other 2K aspect ratios available. They use the same pipeline for text prompts, image editing and RGBA generation. For transparent output, describe the subject and the transparent background explicitly, then save a PNG to retain the alpha channel.

For visual ideas, the independent Qwen Image 2.1 gallery gathers creator-attributed previews across photography, typography, illustration and editing. Check the original post for the inputs and steps behind an example. Qwen-Image-2.1 edits still images; a moving showcase clip involves a separate video step.

In a current ComfyUI installation, search the Template Library for Qwen-Image-2.1 and open Text to Image. The official tutorial also provides Image Edit and Remove Background workflows. Download the exact components selected by the template: generator files go in models/diffusion_models, the encoder in models/text_encoders, and the VAE in models/vae. Choose the matching BF16 or INT8 files from the tutorial.

For a first run, choose a square canvas at about 1.0 MP and keep one output. The current ComfyUI templates use 25 steps, CFG 1, Euler and the simple scheduler. These settings differ from the 40-step Diffusers example and SGLang timing below. A 4.0 MP square canvas is approximately 2048×2048.

For an edit, load your own image in the first reference slot and state what to preserve as well as what to change. The prompt below uses ComfyUI’s reference syntax. Start with one reference before adding more.

SGLang reports the following RTX 4090 24GB measurements from September 20, 2026. Both use 1024×1024, 40 steps, CFG 1 and one RGBA PNG per request. The DiT and VAE stay on the GPU; encoder layers are offloaded to the CPU, with FlashAttention and native precision.

These are median HTTP times after warmup, including PNG serialization and excluding startup. The sampled peak is 22.7 GiB of VRAM; CPU offload also needs host RAM. They describe this runtime and workload, not a general time for native 2K output.

Multiple references, more outputs and batching can change component placement. More offloading trades GPU memory for transfers, and quantization and transfer overhead both affect inference speed. If your local run is slow, compare resolution, steps, reference count and placement with the measured recipe first.

Use cost per usable image when comparing a local workflow with an API. A useful starting calculation is GPU hourly cost × seconds per image ÷ 3,600. At an illustrative $1 per GPU-hour, 18.68 seconds costs about $0.00519 per attempt, or $5.19 for 1,000 attempts. At 21.68 seconds, the same calculation gives about $6.02 for 1,000 edits.

That calculation covers active processing time only. Add model loading, idle rental time, storage and setup work for a rented server. For a GPU you own, include electricity and hardware cost. If only half of your attempts are usable, the processing cost per accepted image doubles.

The image calculator uses the existing 1024×1024, 40-step profiles. Choose generation or editing and enter your expected monthly volume. For a different workload, measure its time and use the formula above; the calculator does not accept custom timing inputs.

Local Qwen is a useful evaluation route when you want control over files, reference images and a reusable editing workflow. A hosted API is a practical alternative when maintaining that environment costs more time than the images save. Choose using the same prompts and source images, including the edits you expect to repeat.

FLUX.2 Klein 9B is another downloadable generation and multi-reference editing model. Its released distilled version uses four inference steps and has a non-commercial license. Compare it for short iteration cycles using the same prompts and output size on your GPU.

As of September 29, 2026, Google lists standard Gemini 3.1 Flash Image output at approximately $0.067 per 1K image, or about $67 for 1,000 images. Text and image inputs cost $0.50 per million tokens; text and thinking output, when present, costs $3 per million tokens. These additional charges sit outside the image-output subtotal. This is an alternative model’s API budget, not a Qwen-Image-2.1 price.

For Alibaba Model Studio, choose the documented Turbo or Pro route and its billing region from the hosted-price section above. Keep those service rates separate from the downloadable base model’s local workload.

For occasional work, compare the API bill with the time spent installing, updating and troubleshooting local software. For a repeatable high-volume workload, measure accepted outputs per hour and include idle capacity before deciding whether self-hosting saves money.

Build a small comparison set from your own work: one layout with exact text, one photograph edit, one identity-preserving reference task and one transparent asset. Keep the target dimensions fixed. Record request time, attempts needed and the reason you reject each result.

Inspect lettering, hands, object relationships and the parts of an edited image that should stay unchanged. View transparent edges against both light and dark backgrounds. A fast first image saves little if it takes several retries or extensive cleanup to become usable. Choose a hosted alternative if it consistently gives you more acceptable results within your time budget.

The Qwen Research License defines non-commercial use as research or evaluation. Commercial use of the materials requires a separate license from Qwen; the license document gives the contact route. Resolve that requirement before building a paid workflow around the downloaded weights.

Self-hosting gives you control over the runtime, while the model license and applicable laws still govern its use.