Direct answer: Call the images endpoint with a size and quality parameter, run a small concurrency pool, and default to low quality for drafts and high quality only for finals.

How Do You Make a Basic API Call?

from openai import OpenAI
client = OpenAI()
r = client.images.generate(
    model="gpt-image-1",
    prompt="flat icon of a paper plane, blue, white background",
    size="1024x1024",
    quality="low",
    n=1)
print(r.data[0].b64_json[:40])

The response returns base64 image data, not a URL, so decode and write it to disk yourself. There is no hosted link to hotlink.

Which Parameters Actually Change the Bill?

Quality dominates. Drafting at low and re-rendering only approved concepts at high is the single biggest saving, and in practice only a small fraction of drafts survive review.

How Do You Run a Batch Without Getting Rate Limited?

Fire requests through a small thread pool rather than one at a time. Four to six concurrent requests is a safe starting point; too many and you hit 429 errors that waste more time than the extra parallelism saves.

from concurrent.futures import ThreadPoolExecutor
def one(p): return client.images.generate(
    model="gpt-image-1", prompt=p,
    size="1024x1024", quality="low")
with ThreadPoolExecutor(max_workers=5) as ex:
    for out in ex.map(one, prompts):
        save(out)

Add retry with exponential backoff on 429 and 500 responses. Without it, a burst at the end of a batch silently drops items.

How Do You Keep Prompts Consistent Across Hundreds of Images?

Fix everything that should not vary and template only what should. Build a prompt from a constant style block — “flat vector style, white background, centered subject, no text” — plus a per-item variable. Changing style words halfway through a batch produces images that look like they came from different tools.

Seed control is limited with this model, so “same style” comes from repeated style text, not from a seed number.

What Goes Wrong at Scale?

Three recurring issues. Base64 payloads are large, so naive scripts hold everything in memory and crash on a batch of a few hundred. Content policy rejections surface as errors mid-run — log the prompt and move on rather than crashing the whole job. And retries without backoff amplify rate limits instead of relieving them.

Who Should Use the API — and Who Should Not

Worth it for teams producing asset libraries, ad variants, or catalog imagery. For a handful of images a week, the browser interface is cheaper in time and worry. This is a volume tool; at low volume the engineering overhead beats the savings.

Quick Summary

• Call the images endpoint with model="gpt-image-1"; responses are base64, not URLs.
• Quality is the biggest cost lever — draft low, final high.
• Use a 4-6 worker pool with backoff to avoid 429 errors.
• Template a constant style block for batch consistency.
• The API pays off at volume, not for occasional single images.

Direct answer: Put the exact text in quotation marks inside your prompt, keep it under about six words, and specify placement and font style; GPT Image 1 will render it faithfully most of the time.

Why Is Text Rendering Such a Hard Problem?

Image models do not “write” — they paint pixels that resemble letters. Long strings compound the error, so a three-word sign works and a two-line paragraph collapses into gibberish.

GPT Image 1 improved this by training on typography-heavy examples. It handles product labels, posters, UI mockups, and simple diagrams. It still struggles with long paragraphs, unusual fonts, and non-Latin scripts.

How Do You Prompt for Clean Typography?

1. Quote the exact text: "OPEN LATE".
2. State the position: “centered on the sign board, upper third of the image”.
3. Name the style: “bold sans-serif, high contrast, no serif flourishes”.
4. Add a negative instruction: “no additional text anywhere else”.

That last line matters. Without it, the model often invents extra words in the background — signs on walls, labels on objects — and those tend to be the garbled ones.

What Does It Cost?

GPT Image 1 is priced per generated image, tiered by resolution and quality. Lower-quality, smaller images cost a fraction of high-quality 1024×1024 output, and the cost gap is roughly an order of magnitude between the cheapest and priciest options. For typography work you often need the higher-quality tier, because lower tiers smear fine letterforms.

Practical advice: prototype at low quality to check layout, then re-render the final at high quality. Never iterate at high quality — it drains budget fast.

Text in Images: Prompt Comparison

The right column gives the model an exact string and an exact place to put it.

Where Does Text Still Break?

Four reliable failure modes. Strings longer than roughly eight words start dropping letters. Thin or script typefaces lose strokes. Text at an angle or in perspective warps. Text that is small relative to the canvas renders as texture rather than letters.

If your design needs a full paragraph, generate the image without text and add the type in a real editor. Fighting the model is slower and less reliable.

Who Should Use It — and Who Should Not

Ideal for designers making mockups, marketers producing ad variants, and developers generating placeholder art with labels. Not ideal for print-ready typography, brand-critical logos, or anything needing pixel-exact kerning. It is a fast draft generator, not a type foundry.

Quick Summary

• GPT Image 1 renders short English text far better than earlier models.
• Quote the exact string, cap it at six words, and state the placement.
• Add “no additional text” to stop background word garbage.
• Prototype at low quality, render finals at high quality.
• Add real type in an editor for paragraphs or brand-critical text.