The API that reads images can now make them. As of today, ParalonCloud serves Z-Image-Turbo — Alibaba's open-weight text-to-image model (Apache 2.0) — behind a standard, OpenAI-compatible POST /v1/images/generations. Same prlc_ key you already use for chat, same base URL, free during the beta.
The cover of this article was generated with it. So were the samples below. No external tools, no retouching — one prompt, one request, a few seconds.
How to use the image generation API (curl, Python)
curl https://paraloncloud.com/v1/images/generations \
-H "Authorization: Bearer prlc_your_api_key" \
-H "Content-Type: application/json" \
-d '{
"model": "z-image-turbo",
"prompt": "A cinematic photo of a modern graphics card on a black background with a glowing emerald green eye in the fan hub, the words PARALON CLOUD written in clean white letters below it",
"size": "1024x1024",
"seed": 42
}'
The response follows the OpenAI Images API shape — data[0].b64_json is your PNG. With the OpenAI Python SDK it's the usual two-line change:
from openai import OpenAI
import base64
client = OpenAI(base_url="https://paraloncloud.com/v1", api_key="prlc_your_api_key")
img = client.images.generate(model="z-image-turbo", prompt="…", size="1024x1024", response_format="b64_json")
open("out.png", "wb").write(base64.b64decode(img.data[0].b64_json))
No key yet? Sign in to the Console, create one, done.
Or just type it in Discord
The fastest way to see what it does is our Discord: join at discord.gg/VHn9KevdTK, go to the image channel and type:
/imagine prompt: a street food vendor stirring a wok at a Taipei night market, pink neon sign reading 'NOODLES 24H', rain-slick pavement
The bot calls the exact same API and posts the image back in the channel. Optional size: (square, landscape, portrait, wide) and seed: for reproducible results. Nothing is stored anywhere — the image goes from the GPU to Discord and that's it.
What it looks like
These were generated through the public endpoint while writing this post — no cherry-picking beyond one seed each:
1344×896, seed 7, 5.3 s. Every element of a 12-part prompt landed, including the exact neon text.
1344×896, seed 31, 5.2 s. Skin, beard, water droplets, catchlights in the eyes — portrait work is where photoreal models usually fall apart, and this one doesn't.
1344×896, seed 4403, 5.3 s. Same endpoint, completely different register — stylized 3D animation-film look, expressive character, clean hologram UI. (Yes, that's our capybara. Press the button, get an image.)
Image generation API specs and limits
| Model | z-image-turbo — Tongyi-MAI/Z-Image-Turbo, 6B DiT, Apache 2.0 |
| Speed | ~4–6 s per 1024px image end to end (measured on RTX 4090 nodes, 9 steps) |
| Sizes | any WxH from 256² up to 1536² pixels (multiples of 16) |
| Per request | up to 4 images (n) |
| Options | seed (reproducible), steps (extension, default 9) |
| Output | b64_json PNG |
| Price | free during beta |
| Limits (beta) | 4 images/minute and 30 images/day per key (counted per image, so n: 4 uses 4) — higher tiers coming |
What it's great at: photorealistic scenes, cinematic lighting, product shots, short text inside images, speed. Where bigger closed models still win: very long text layouts, instruction-based editing, unusual multi-step compositions. We'll add an edit-capable model next — see below.
Why this matters for builders
Image APIs have mostly been a closed-vendor business with per-image pricing that adds up fast at volume. An open-weight model on an OpenAI-compatible endpoint means you can build thumbnail generators, product-image pipelines, social graphics, game assets or UI mockup tools without a vendor account, and move between providers by changing a base URL.
And because this runs on consumer GPUs in our distributed network — 3090s, 4090s, 5090s owned by independent providers — the economics are different from a hyperscaler: the hardware is already there, idle most of the day. That's what lets us run this free in beta and price it aggressively later.
What people build with an image generation API
The requests we see are rarely "make me art". They're pipelines:
- Thumbnails and social graphics — a blog or video title in, a 1.91:1 or 9:16 image out, hundreds a day.
- Product and catalog images — the same SKU in ten scenes and lightings, no studio.
- Game and app assets — icons, textures, backgrounds, character concepts at prototype speed.
- UI mockups and placeholders — realistic imagery for landing pages and demos instead of grey boxes.
- Marketing variants — A/B-testing visuals at volume, where per-image cost decides whether the experiment happens at all.
- Agents and tools — a coding or content agent that can make an image, not just describe one (the pi and OpenClaw setups work unchanged; the base URL is the same).
Speed matters in every one of those: at ~5 s an image, generation stops being a batch job you schedule and becomes a step you can put in a request path.
Pricing: how it compares with DALL-E, fal and Replicate
Per-image prices for hosted image APIs, approximate, August 2026 (check the vendors for current numbers):
| Model | Price per image | Typical latency | |
|---|---|---|---|
| OpenAI | gpt-image (via API) | ~$0.04 – $0.17 depending on quality/size | 20 – 60 s |
| fal.ai / Replicate | FLUX.1 [schnell] | ~$0.003 | ~1 – 3 s |
| fal.ai / Replicate | FLUX.1 [dev] | ~$0.025 | ~5 – 10 s |
| ParalonCloud | Z-Image-Turbo | free during beta (paid tier will be priced per image, well under the closed APIs) | ~4 – 6 s |
Two things that don't show up in a price column: the model weights are Apache 2.0 (you can use the outputs commercially, and nothing stops you from running the same model yourself later), and the endpoint is OpenAI-compatible, so switching providers is a base-URL change, not a rewrite.
Under the hood
Each image model is just another worker type in our scheduler: a container with the model on one GPU, registered like an LLM worker, routed by an image gateway that speaks the OpenAI shape. If you're curious how we place models across a heterogeneous swarm of consumer cards, we wrote about it in Scheduling LLMs across mixed GPUs — the same machinery now schedules images too.
Next on the list: an image-editing model (instruction-based edits, references) and video. If there's a specific model you want us to serve, tell us on Discord — the one people ask for first usually ships first.
FAQ
Is there a free image generation API?
Yes — this one, during the beta. Sign in, create a prlc_ key in the Console, and call POST /v1/images/generations. No card required. A paid tier with higher limits and priority will follow; the free tier stays.
Is the image API OpenAI-compatible?
Yes. Same request and response shape as the OpenAI Images API (model, prompt, size, n, response_format: b64_json). The OpenAI SDKs work with base_url="https://paraloncloud.com/v1".
Which model is it, and can I use the images commercially? Z-Image-Turbo (Tongyi-MAI), released under Apache 2.0. The license permits commercial use of the model and its outputs. You remain responsible for what you generate and how you use it — see our terms.
How fast is it, really? ~4–6 seconds for a 1024×1024 image end to end through the public endpoint, measured on RTX 4090 nodes (9 diffusion steps). Larger sizes take proportionally longer; up to 1536² is allowed.
Can I reproduce an image?
Yes — pass seed. Same model, same prompt, same size and seed → the same image.
What are the limits? Up to 4 images per request, up to 1536² pixels, and during beta 4 images per minute and 30 per day per key (images, not requests — separate from the chat endpoint's limit; need more for a real project? ask on Discord). You get a clear 429 with the reason when you hit one. If every worker is busy you get a 503 and can retry; the Discord bot does that for you.
Does it do image editing / image-to-image? Not yet. Text-to-image only today; an instruction-based editing model is next on the roadmap.
Is it the same key as the LLM API?
Yes — one prlc_ key covers chat completions, vision, and images. Usage shows up per key in your Console.
