On 2026-09-09 OpenAI shipped ChatGPT Images 2.5 with two API tiers, Flare and Sunburst. The same week Ant Group's inclusionAI released LLaDA-Image, a 6B text-to-image model (Base 50 steps, Turbo 4 steps via Twin-DMD distillation). One event pushes closed APIs faster and stronger; the other makes open weights deployable with dignity. Text-to-image has entered a fork: the speed tier of closed APIs versus the controllability of open weights.
First, a note on division of labor with the site's existing coverage. Our reasoning image model capability review on 8-26 benchmarks the ceiling of GPT Image 2, Nano Banana Pro, Seedream, Ideogram, and FLUX.2. This article opens a different ledger: same image, what does it cost to pay per image via a closed API versus self-hosting open weights, and who stays in control. In this batch the hot-take piece covers ChatGPT Images 2.5, the resource roundup catalogs LLaDA-Image weights, and the local deploy SOP gives run steps. This review is the cost-and-control spine.
A boundary up front: this is a representative comparison, not a hands-on benchmark. Costs are extrapolated from public pricing with the methodology stated explicitly. Third-party platform prices (Replicate / fal.ai) are taken from the official site 2026-09 snapshot; per-image prices for direct closed APIs and domestic cloud APIs were not published in that snapshot, so they are marked "confirm with the official site" rather than invented. VRAM floors, throughput, and electricity are engineering estimates, not official figures, and serve only as order-of-magnitude guidance.
The same week, two events: image generation splits in two
For two years the text-to-image story was "who draws better." GPT Image 2 made reasoning generation standard, Seedream lifted Chinese small-text to the usable line, and Nano Banana Pro led editing. As the capability gap closes, the real split is on a different axis: how the image is made, what it costs, and who controls it.
The closed camp's play is "the API keeps getting faster": no GPU, queue, or model-update management; you send a request and the newest weights run in the vendor's datacenter and return the image. The open camp's play is "here are the weights": LLaDA-Image 6B, FLUX, and Stable Diffusion open checkpoints so you deploy on your own GPU and fine-tune. The two paths do not replace each other; they split users by volume and control.
This fork matters especially for technical practitioners, because you are neither a pure dabbler nor a big company with an unlimited budget. What you must calculate is: for this batch of images, should I call an API, or should I buy a card and run it myself?
Five routes: what the ledger looks like
Spread the market's options out and you get five routes with completely different cost structures:
| Route | Representative | Billing | Ops burden | Controllability |
|---|---|---|---|---|
| Closed API direct | OpenAI ChatGPT Images 2.5 / Google Imagen family / Jimeng Seedream family | Per image or per token, confirm price with official site | None | Low, no fine-tune |
| Self-hosted open weights | Ant LLaDA-Image 6B, FLUX family, SD family | GPU amortization + electricity + ops (mostly fixed) | High | High, LoRA / fine-tune |
| Third-party inference platform | Replicate / fal.ai hosted open models | Per second or per image, official 2026-09 snapshot | Low | Medium, params only |
| Local consumer hardware | Single 4090 / 5090 etc. | One-time GPU + electricity, marginal cost near zero | Medium | High |
| Domestic cloud API | Alibaba Bailian / Tencent Cloud / Volcano Ark | Per image or per token, confirm price with official site | None | Medium, data onshore |
The first and fifth are the same "rent compute" logic, differing only in data and compliance; the second and fourth are the same "buy compute" logic, differing only in whether it is consumer grade; the third is the compromise between them: you do not maintain a card, but you pay a platform hosting fee and your model choice is constrained.
The key is the cost-curve shape: renting compute is linear while buying compute is fixed (marginal cost trends to zero). Past enough volume, amortized unit cost of buying dives below renting. The only questions are volume size and whether you tolerate the ops.
A common misconception: self-hosting is not "free." It converts the explicit per-image cost into implicit costs (hardware depreciation, electricity, VRAM tuning, model updates, troubleshooting). Include engineer time in the math: a card's saved API bill may not offset hours spent fixing out-of-memory errors. That gap is exactly what third-party platforms and domestic clouds fill, at a platform premium in the unit rate.
What one image actually costs: two volume tiers
To make the ledger concrete, split it into two tiers: low-frequency "100 images/day" (about 3,000/month) and high-frequency "10,000 images/day" (about 300,000/month). Costs are extrapolated from public pricing; the methodology is stated under the table.
| Route | 100/day (about 3k/month) monthly cost | 10,000/day (about 300k/month) monthly cost | Cost structure |
|---|---|---|---|
| Closed API direct | About $150 (at $0.05/image, price confirm with official site) | About $15,000 | Purely linear, zero ops |
| Third-party hosted open | About $75 (flux-dev $0.025/image, official 2026-09 snapshot) | About $7,500 | Per image/second, cold start included |
| Self-hosted (single 4090) | Fixed about RMB 600-1500/month (engineering estimate) | Fixed about RMB 600-1500/month (Turbo 4-step covers it) | Mostly fixed |
| Domestic cloud API | Similar to or slightly below closed direct, confirm with official site | Same | Linear, data onshore |
| Local consumer hardware | One-time GPU + electricity, marginal near zero | Multi-card or queue, engineering estimate | Fixed + time |
Methodology: closed API direct uses a $0.05/image midpoint (confirm with official site); third-party uses Replicate's official 2026-09 snapshot price of $0.025/output image for flux-dev; self-host assumes one RTX 4090 (about RMB 13,000, three-year amortization) plus electricity and light ops, fixed about RMB 600-1500/month (engineering estimate); fal.ai's 2026-09 snapshot shows serverless H100 as low as $1.89/hour. Representative, not a hands-on benchmark.
The one conclusion worth memorizing: self-hosting is a fixed cost, closed API is a linear cost, and roughly a hundred images per day is the watershed. At $0.05/image, closed API catches up to self-host's fixed overhead at about 2,000 images (roughly 67/day); past that, every extra image is essentially free on self-host. Conversely, if you draw only a few hundred a month, a card's electricity and amortization will not pay back, and the API is cheaper.
The big comparison table and scenario selection
Lay the five routes across seven dimensions for direct comparison:
| Dimension | Closed API | Self-host | Third-party | Local consumer | Domestic cloud |
|---|---|---|---|---|---|
| Per-image cost at scale | Limited linear drop | Trends to zero | Medium | Trends to zero | Linear |
| Latency | Low (vendor optimized) | Depends on GPU | Medium (queue) | Depends on GPU | Low |
| Controllability (LoRA/ControlNet) | None | Full | Partial | Full | Partial |
| Compliance / data export | Export risk | Data stays local | Depends on platform | Data stays local | Data onshore |
| Chinese text rendering | Strong (GPT/Seedream) | LLaDA CN/EN usable | Depends on base | Depends on base | Strong |
| Iteration speed | Vendor updates = latest | You follow community | Platform updates | You follow community | Vendor updates |
| Best for | Speed, low ops | Control, volume | Compromise | Privacy, tinkering | Compliance sensitive |
Translated into concrete scenarios, selection is not complicated:
- Personal tinkering / low-frequency trial: closed API direct or third-party platform. Zero threshold, no card to maintain; drawing a few dozen images costs less than a coffee.
- E-commerce batch output (10k/day tier): self-hosted open weights (LLaDA-Image Turbo / quantized FLUX) or domestic cloud API. Past the linear cost inflection, unit cost drops off a cliff; this is where self-hosting is most comfortable.
- Data-sensitive industries (medical / finance / government): self-host or domestic cloud API. Closed APIs may export data; sensitive assets should prefer data-onshore or data-local options.
- Need to fine-tune a brand style: open weights. Closed APIs cannot modify weights; brand colors, fixed layouts, and signature styles can only be achieved with LoRA or fine-tuning on open models.
- Pursue strongest quality and newest capability: closed API (ChatGPT Images 2.5 / Imagen / Seedream family). The capability ceiling is still held by closed vendors, and vendor updates mean you get the latest immediately.
One more local-hardware table to help you decide what card to buy:
| GPU | VRAM | Models runnable (engineering estimate) |
|---|---|---|
| RTX 4060 | 8GB | SD1.5 / SDXL quantized, 6B tight |
| RTX 4070 / 4080 | 16GB | SDXL / SD3, FLUX quantized |
| RTX 4090 / 5090 | 24GB | LLaDA-Image 6B BF16/FP8, FLUX-dev quantized, smooth Turbo |
| L40S / A6000 | 48GB | FLUX full precision + multiple LLaDA instances |
| A100 / H100 | 80GB | Batch, fine-tune training, multi-model parallel |
Engineering estimate: LLaDA-Image 6B BF16 weights are about 12GB, FP8 about 6GB, so a 24GB card loads it; Base at 50 steps is slower, while Turbo at 4 steps via Twin-DMD distillation has higher throughput and covers the 10k/day tier. Official VRAM floor was not published, so treat this as order-of-magnitude only. Power and noise matter: the 4090 draws heavily and needs a matching case and PSU, while the fanless L40S suits always-on office use. Throughput, power, and driver stability decide real daily output.
Four pitfalls
Pitfall one: license not declared. The variable we most want to underline: at release, the LLaDA-Image repository's license field was null, so no license was declared. Open weights do not equal free commercial use; confirm scope before shipping. FLUX and SD have explicit licenses, treat "does the license permit my use case" as a hard gate. A null license means "unstated, risk borne by the user," not "use freely." Before production, contact inclusionAI, wait for an official license, or use FLUX/SD as a commercial fallback.
Pitfall two: per-second billing and cold starts. Replicate private models bill by instance online time and include setup and idle time (official 2026-09 snapshot: setup, idle, active); fal.ai serverless bills per call or output, H100 as low as $1.89/hour. Keep a Replicate private deployment running and it burns money even when idle. Before batch runs, benchmark latency and the bill, not just unit price.
Pitfall three: Chinese rendering still has gradients. Closed APIs (GPT Image 2 / Seedream family) have Chinese small-text near the usable line; LLaDA-Image supports both Chinese and English text rendering, with Qwen-Image-Bench scores of 53.53 in English and 53.38 in Chinese. But dense infographics and multilingual posters still trail the top closed models, so do not batch-order directly; prototype at small volume first and check the error rate.
Pitfall four: data export and compliance. Requests and images from closed APIs may leave the country; sensitive industries such as medical, finance, and government should prefer domestic cloud APIs (data onshore) or self-hosting (data local). Domestic cloud and closed direct prices are both confirm-with-official-site; pair this review with the resource roundup and the local deploy SOP.
To close: the competition is no longer who draws better, but whether you pay a linear bill for speed or a fixed bill for control. Calculate your volume, then choose API or card.
FAQ
Q1: Which is cheaper, closed API or self-hosted open weights? A1: It depends on volume. At $0.05/image (confirm with official site), closed API monthly cost grows linearly with volume; self-host is a fixed cost (GPU amortization + electricity + ops) that you cross past at roughly a hundred images per day. Use the API for low frequency, self-host for batches. Representative comparison, not a hands-on benchmark.
Q2: What GPU do I need to run LLaDA-Image 6B? A2: Engineering estimate: 6B BF16 weights are about 12GB, FP8 about 6GB, so a single 24GB consumer card (4090/5090) runs it; Base at 50 steps is slower, while Turbo at 4 steps via Twin-DMD distillation has higher throughput and a single card can cover the 10k/day tier. Official VRAM floor was not published; the above is an engineering estimate. Also note the repository license is null, so confirm commercial authorization first.
Q3: What are the traps in per-second or per-image billing on third-party platforms? A3: Replicate private models bill by instance online time including setup and idle (official 2026-09 snapshot); fal serverless bills per call or output, with H100 as low as $1.89/hour. Cold starts, warm-up, and minimum billing units all enter the cost; benchmark real latency and unit price before any batch run.
Q4: How far apart are closed and open on Chinese text rendering? A4: Closed APIs (GPT Image 2 / Seedream family) have Chinese small-text near usable; LLaDA-Image supports both Chinese and English text rendering, with Qwen-Image-Bench Chinese 53.38 and English 53.53. Prototype dense infographics and multilingual posters at small volume first; do not batch-order directly.
Q5: How do I choose on data compliance and export? A5: Closed API data may leave the country; sensitive industries (medical / finance / government) should prefer domestic cloud APIs (data onshore) or self-hosting (data local). Domestic cloud and closed direct prices are both confirm-with-official-site. Self-hosting also requires confirming the model license: LLaDA-Image declared no license, so secure rights before commercial use.