This guide covers running Z-Image Turbo on Runpod, either through the public endpoint API or in ComfyUI on your own pod. Z-Image is a 6-billion-parameter image model from Alibaba's Tongyi Lab, and Turbo is the distilled variant that generates in eight steps instead of the usual twenty-plus.
Six billion parameters is small by current standards, and that's the point. Z-Image Turbo fits on a 16 GB card at full precision and on much less when quantized, which makes it a practical choice for high-volume generation where per-image cost and latency matter more than squeezing out the last few percent of quality.
What is Z-Image?
Z-Image (造相) is a text-to-image model developed by Alibaba's Tongyi Lab. It uses a Scalable Single-Stream DiT architecture, or S3-DiT, in which text tokens, visual semantic tokens, and image VAE tokens are concatenated at the sequence level into one unified input stream rather than being processed through separate branches. That design is what lets a 6B model hold its own against considerably larger ones.
Three variants have been released:
- Z-Image-Turbo: The distilled version. Generates in eight NFEs (number of function evaluations) and fits within 16 GB of VRAM. This is the one covered here and the one available as a Runpod endpoint.
- Z-Image-Base: The non-distilled foundation model, intended for community fine-tuning and custom development.
- Z-Image-Edit: Fine-tuned for instruction-based image editing.
What the model is known for:
- Photorealistic output at a parameter count where you'd normally expect a quality drop
- Bilingual text rendering, handling both Chinese and English text inside images
- Prompt enhancement with reasoning, which expands short prompts before generation
- Low latency, with Tongyi Lab reporting sub-second inference on H800-class hardware
The weights and code are published at github.com/Tongyi-MAI/Z-Image and on Hugging Face.
Why run Z-Image on Runpod?
Two paths, depending on what you're building.
If you need images in an application, Runpod hosts Z-Image Turbo as a public endpoint at $0.005 per image. No deployment, no model files, no GPU selection. You post a prompt and get a URL back.
If you need control over the workflow, LoRAs, ControlNet, upscaler chains, batch pipelines, you deploy ComfyUI on a pod and run the model yourself. Z-Image's modest VRAM footprint means that's an RTX 4090 rather than an A100, and you pay per second while the pod runs.
Most teams end up using both: the endpoint for production traffic, a pod for building and testing the workflow that feeds it.
Option A: Use the Z-Image Turbo public endpoint
The fastest path to a generated image. Create an API key, then:
curl -X POST "https://api.runpod.ai/v2/z-image-turbo/runsync" \
-H "Authorization: Bearer $RUNPOD_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"input": {
"prompt": "A serene Japanese garden with cherry blossoms, soft morning light",
"size": "1024*1024",
"seed": -1,
"output_format": "png"
}
}'The response returns output.image_url along with the cost of the generation.
Parameters worth knowing:
- prompt (required): Supports English and Chinese.
- image: A URL, which switches the endpoint into image-to-image mode.
- size: Defaults to 1024*1024. Also accepts 512*512, 768*768, 1280*1280, 1024*768, 768*1024, 1280*720, and 720*1280.
- strength: How far image-to-image generation departs from the input. Defaults to 0.8, range 0.0 to 1.0.
- seed: Set a value for reproducible output, or -1 for random.
- output_format: png, jpeg, or webp.
Pricing is a flat $0.005 per image regardless of size, and you aren't charged for failed generations. Generated image URLs expire after seven days, so download anything you want to keep.
Use /run instead of /runsync if you'd rather get a job ID immediately and poll for the result. You can also test the endpoint interactively in the Runpod Hub playground before writing any code.
Option B: Run Z-Image Turbo in ComfyUI on a pod
Take this path when you need LoRAs, ControlNet, custom samplers, or any multi-step graph the endpoint doesn't expose.
GPU requirements for Z-Image Turbo
Z-Image is unusually forgiving here. Figures below are for the diffusion model plus the Qwen3-4B text encoder:
- 6–8 GB VRAM (RTX 3060 12GB, RTX 4060 Ti): GGUF and fp8 quantizations
- 16 GB VRAM (RTX 4080, A4000, L4): The bf16 checkpoint, which is what the official ComfyUI workflow uses
- 24 GB VRAM (RTX 4090, RTX 3090): bf16 with headroom for ControlNet, LoRAs, and batch generation
- 40 GB+ VRAM (L40S, A6000, A100): High-throughput batch pipelines and multi-workflow queues
A 24 GB card is the comfortable default. There's little reason to go higher unless you're batching.
Templates for running Z-Image on Runpod
ComfyUI (official Runpod template) Runpod's first-party template. Current ComfyUI build on CUDA 12.8, with ComfyUI-Manager, KJNodes, Civicomfy, and ComfyUI-RunpodDirect pre-installed. ComfyUI copies to your workspace on first boot. Wait for [ComfyUI-Manager] All startup tasks have been completed. in the pod logs before opening the interface.
For other options, browse console.runpod.io/hub and search for ComfyUI. The Hub is a live catalog, so check the image version and last-updated date on community templates before deploying.
Step 1: Create a Runpod account
Go to runpod.io and sign up with email, GitHub, or Google. Add credits or a payment method so you can deploy a GPU.
Step 2: Deploy a ComfyUI pod
- Open the Pods section and select an RTX 4090 or another 24 GB card.
- Click Change Template and select the official ComfyUI template.
- Set container disk to at least 30 GB. Z-Image's files are small relative to most current models, but leave room for LoRAs and outputs.
- Attach a network volume if you'll return to this setup, so model files persist between deploys.
- Click Deploy.
The pod comes up in under 30 seconds. Template setup takes a few minutes longer on first boot.
Step 3: Download the model files
Z-Image needs three files, and they're modest compared to most current image models.
- Text encoder: qwen_3_4b.safetensors → ComfyUI/models/text_encoders/
- Diffusion model: z_image_turbo_bf16.safetensors → ComfyUI/models/diffusion_models/
- VAE: ae.safetensors → ComfyUI/models/vae/
The ComfyUI-repackaged files are in the Comfy-Org z_image_turbo repository on Hugging Face.
If you want ControlNet, add one more file:
- Z-Image-Turbo-Fun-Controlnet-Union.safetensors → ComfyUI/models/model_patches/
Note that this goes in model_patches, not the usual controlnet directory. Putting it in the wrong folder is the most common reason the ControlNet workflow fails to load.
Step 4: Open ComfyUI and generate
Once the pod shows a running state, click Connect and open port 8188.
Update ComfyUI before loading anything. Z-Image support depends on recent core nodes, and a stale build is the usual cause of missing-node errors on load.
Load the Z-Image Turbo workflow from the Template Library, or from ComfyUI's Z-Image documentation. Then verify:
- Load Diffusion Model points at z_image_turbo_bf16.safetensors
- The CLIP loader points at qwen_3_4b.safetensors
- Load VAE points at ae.safetensors
Turbo is distilled to eight steps. The workflow template ships with the correct sampler settings already, so run it once before changing anything. If you find yourself raising the step count into the twenties, you're fighting the distillation rather than improving output.
Enter a prompt, click Queue Prompt, and the result appears in the interface and saves to /workspace/ComfyUI/output.
Pro tips
Test on the endpoint before you build a pod. At $0.005 per image, evaluating whether Z-Image suits your use case costs less than the pod hour you'd spend setting it up. If the output isn't right, you've learned that for pennies.
Use the ControlNet workflow for structural control. The Fun Union ControlNet handles Canny edge guidance and other conditioning against a reference image, which is where a lot of production image work actually lives.
Try text rendering directly. Bilingual in-image text is one of the model's stronger capabilities and worth testing against your own use case rather than taking on faith.
Keep prompts descriptive, not tag-stacked. Z-Image's prompt enhancer expands short inputs, but a clear descriptive sentence gives it better material to work with than a comma-separated keyword list.
Attach a network volume. Pod storage is ephemeral. A network volume keeps the checkpoint, encoder, LoRAs, and saved workflows across sessions.
Stop your pod when you're done. Runpod bills by the second while a pod runs.
Wrapping up
Z-Image Turbo occupies a useful spot: small enough to run almost anywhere, fast enough at eight steps to iterate properly, and priced flatly enough per image on the endpoint that high-volume generation is straightforward to budget. Start on the endpoint, move to a pod when you need the graph.
Ready to try it? Test Z-Image Turbo in the playground, or deploy the ComfyUI template for full workflow control.
FAQ
What's the difference between Z-Image Turbo, Base, and Edit?
Turbo is the distilled version, generating in eight steps and fitting within 16 GB of VRAM. Base is the non-distilled foundation model, aimed at fine-tuning and custom development. Edit is fine-tuned for instruction-based image editing. Turbo is the variant available as a Runpod endpoint.
What GPU do I need to run Z-Image Turbo on Runpod?
The bf16 checkpoint used in the official ComfyUI workflow fits in 16 GB, so an RTX 4080 or L4 works. A 24 GB card such as the RTX 4090 gives headroom for ControlNet and batching. Community fp8 and GGUF quantizations bring it down to 6–8 GB cards.
How much does Z-Image Turbo cost on the public endpoint?
$0.005 per image, flat, regardless of output size. You aren't charged for failed generations. Running it yourself on a pod is billed per second of GPU time instead, which is usually the better economics only at sustained volume.
Does Z-Image support image-to-image?
Yes. On the public endpoint, pass an image URL along with your prompt and use the strength parameter to control how far the result departs from the input. In ComfyUI, you build it into the graph as you would with any diffusion model.
Why is my output worse when I raise the step count?
Turbo is distilled to eight steps. Its sampler schedule is built around that, so adding steps doesn't behave the way it does with a non-distilled model. Use the workflow template's default settings, and if you want more steps to help, use Z-Image-Base instead.
Can I use Z-Image as an API instead of a UI?
Yes, two ways. The public endpoint gives you a REST API with no deployment at all. Or containerize a custom ComfyUI workflow and deploy it to Runpod Serverless, which scales from zero and bills per second of compute.
