Generate Images in Python With OpenAI's GPT Image API

Install the OpenAI Python Library

Confirm that you’re running Python version 3.10 or higher, create and activate a virtual environment, and install the OpenAI Python library:

• Windows
• Linux + macOS

PS> python --version
Python 3.14.6
PS> python -m venv venv
PS> .\venv\Scripts\activate
(venv) PS> python -m pip install openai==3.13.0

$ python --version
Python 3.14.6
$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install openai==3.13.0

The openai package gives you access to the full OpenAI API. In this tutorial, you’ll focus on image generation, which lets you interact with the GPT Image models to create and edit images from text prompts. For text generation using OpenAI’s API, see How to Integrate ChatGPT’s API With Python Projects.

Get Your OpenAI API Key

You need an API key to make successful API calls. Sign up with OpenAI, then open the API keys page in your account dashboard. From there, you can create new secret keys and manage or delete the ones that you already have.

A key on its own isn’t enough, though. Image generation is a paid API service, so your organization also needs a payment method and available credit before any of the requests in this tutorial will go through. Set that up on the billing page. If you skip it, then your first call returns a quota or billing error rather than an image.

Create a new secret key and copy the value shown in the pop-up window.

Always keep this key secret! You’ll only see the key value once, so store it somewhere safe before you close the window. You’ll use it in your project in a moment.

Save Your API Key as an Environment Variable

A quick way to make your API key available to your Python scripts is to store it as an environment variable. Select your operating system to learn how:

• Windows
• Linux + macOS

(venv) PS> $ENV:OPENAI_API_KEY = "<your-key-value-here>"

(venv) $ export OPENAI_API_KEY="<your-key-value-here>"

With this command, you make the API key accessible under the environment variable OPENAI_API_KEY in your current terminal session. Keep in mind that you’ll lose it if you close your terminal.

You can give your variable any name, but using OPENAI_API_KEY, as suggested by the OpenAI documentation, lets you run the provided code examples without additional setup.

One more thing may stand between you and your first image: Depending on your account, OpenAI may require organization verification before you can use the GPT Image models, so a valid key doesn’t guarantee access. If your requests come back with a model-access error that points to verification, then complete the verification step in your account settings and try again.

With the logistics out of the way and your API key safely stored, you’re now ready to create some images from text prompts.

Set the Size and Quality of Your Image

Both size and quality default to "auto", which lets the model decide. The image above came back at 1254 by 1254 pixels, which is a perfectly reasonable choice, but probably not what you want if you’re building the result into an application.

Edit your script and pass a few more keyword arguments to customize the result:

 1from base64 import b64decode
 2
 3from openai import OpenAI
 4
 5client = OpenAI()
 6
 7PROMPT = "A vaporwave computer"
 8
 9response = client.images.generate(
10    model="gpt-image-2.5-flare",
11    prompt=PROMPT,
12    n=1,
13    size="1024x1024",
14    quality="low",
15)
16
17with open("vaporwave.png", mode="wb") as png:
18    png.write(b64decode(response.data[0].b64_json))

Here’s what the three new keyword arguments do:

• Line 12 passes the integer 1 to the parameter n. This parameter lets you define how many new images you want to create with the prompt. The value of n needs to be between one and ten and defaults to 1.

• Line 13 sets a value for size, which defines the image dimensions as a "widthxheight" string. "1024x1024" is a safe choice for a square image, while "1536x1024" gives you a landscape image and "1024x1536" gives you a portrait image. If you’d rather not decide, then "auto" lets the model choose.

• Line 14 sets quality, which accepts "low", "medium", "high", "xhigh", "max", or "auto". Lower quality uses fewer tokens and produces results faster, so it’s a good choice during development.

The effect of quality is supposed to show up in the fine detail rather than in the overall look. Here’s "A vaporwave computer" at "low" and at "high", zoomed in on the monitor:

Can you tell which one cost more than eight times as many tokens? Neither can I. Both monitors show readable icon labels, crisp grid lines, and a sunset with palm trees. Higher quality settings give the model a bigger budget for textures and small text, but at this size, you’d need a magnifying glass to find where it went.

So for a scene like this one, "low" is all you need. Whether a higher setting pays off depends on your image, and you’d expect to see the difference first in fine details like small text or intricate textures. Rather than paying for higher quality by default, run your own prompt once at "low" and once at "high", and step up only if you can see the difference.

What you can compare exactly is what the model spent. These are counts from single runs of this one prompt, so treat them as a rough scale rather than a price list. At 1024 by 1024 pixels, the low-quality request used 206 tokens in total, while the high-quality one used 1,766. Climbing further up the ladder gets expensive quickly: the same prompt cost 3,132 tokens at "xhigh" and 7,034 at "max".

Tokens only become money once you apply the rate for the kind of token you spent, and the three kinds bill differently. As of September 2026, OpenAI charges $5 per million text input tokens, $8 per million image input tokens, and $30 per million image output tokens.

Generating an image from a text prompt uses nearly all the tokens for image output. You can check the breakdown yourself because every response has a .usage attribute. Add these lines to the end of create.py and run it:

usage = response.usage
print(usage.input_tokens, usage.output_tokens, usage.total_tokens)

For the low-quality request above, that printed 10 196 206. The input_tokens are what reading your text prompt cost, and the output_tokens are what drawing the image cost. In each of these runs, only ten tokens went to the text prompt, and the rest were image output tokens.

Now you can put a price on it. At the rates above, the 196 image output tokens cost 196 × $30 / 1,000,000, or about $0.006, and the ten text input tokens add a negligible $0.00005. So the whole low-quality image costs well under a cent. The same calculation for the 7,034-token "max" request lands at around twenty cents. Check the pricing page for current rates before you build a budget on them.

Because lower-quality images are so much less expensive, you just saved some money by using "low" during development. As a successful saver, maybe you’d like to save something else—your image data.

Save the Whole Response as JSON

Writing the image straight to a PNG works nicely for a single picture. But the response holds more than the image—it also includes the size, quality, and token usage for the request. If you ask for several images at once with n, then it holds all of them.

To keep all of that around, store the whole JSON response in a file instead. And while you’re at it, why not also add a bit more detail to your prompt:

 1import json
 2from pathlib import Path
 3
 4from openai import OpenAI
 5
 6client = OpenAI()
 7
 8PROMPT = "An eco-friendly computer from the 90s in the style of vaporwave"
 9DATA_DIR = Path.cwd() / "responses"
10
11DATA_DIR.mkdir(exist_ok=True)
12
13response = client.images.generate(
14    model="gpt-image-2.5-flare",
15    prompt=PROMPT,
16    n=1,
17    size="1024x1024",
18    quality="low",
19)
20
21file_name = DATA_DIR / f"{PROMPT[:5]}-{response.created}.json"
22
23with open(file_name, mode="w", encoding="utf-8") as file:
24    json.dump(response.to_dict(), file)

With a few additional lines of code, you’ve added file handling to your Python script using pathlib and json:

• Lines 9 and 11 define and create a data directory called "responses/" that’ll hold the API responses as JSON files.

• Line 21 defines a variable for the file path where you want to save the data. You use the first five characters of the prompt and the timestamp from the response to build the filename, which is distinctive enough while you’re experimenting. If your prompt starts with characters that aren’t allowed in filenames, like / or :, then swap the prompt fragment for a fixed prefix.

• Lines 23 and 24 create a new JSON file in the data directory and write the API response to it. The response is an object from the OpenAI library, which json.dump() can’t serialize directly, so you first call .to_dict() to turn it into a plain Python dictionary.

With these additions, you can now run your script and generate images, and the image data will stick around in a dedicated file within your data directory:

(venv) $ python create.py
(venv) $ ls responses/
An ec-1789379975.json

Did you run the script and inspect the generated JSON file? Looks like gibberish again, doesn’t it? That’s the same Base64-encoded data as before, just wrapped in the rest of the response. With the long Base64 string shortened and some fields left out, the file’s structure looks like this:

{
  "created": 1789379975,
  "data": [
    {"b64_json": "iVBORw0KGgoAAAANSUhEUgAA..."}
  ],
  "quality": "low",
  "size": "1024x1024",
  "usage": {"input_tokens": 10, "output_tokens": 196, "total_tokens": 206, ...}
}

The keys mirror the attributes that you used before: response.data[0].b64_json on the object becomes ["data"][0]["b64_json"] in the dictionary. In the next section, you’ll write a small script that turns any of these saved responses into PNG files that you can look at.

Convert Saved Responses to PNG Files

You just saved a PNG image as a Base64-encoded string in a JSON file, together with the metadata that came with it. To look at the image, you need to decode that string again, just like you did in create.py. This time, though, you’ll write a separate script that can convert any saved PNG response, no matter how many images it holds:

 1import json
 2from base64 import b64decode
 3from pathlib import Path
 4
 5DATA_DIR = Path.cwd() / "responses"
 6JSON_FILE = DATA_DIR / "An ec-1789379975.json"
 7IMAGE_DIR = Path.cwd() / "images" / JSON_FILE.stem
 8
 9IMAGE_DIR.mkdir(parents=True, exist_ok=True)
10
11with open(JSON_FILE, mode="r", encoding="utf-8") as file:
12    response = json.load(file)
13
14for index, image_dict in enumerate(response["data"]):
15    image_data = b64decode(image_dict["b64_json"])
16    image_file = IMAGE_DIR / f"{JSON_FILE.stem}-{index}.png"
17    with open(image_file, mode="wb") as png:
18        png.write(image_data)

The script convert.py will read a JSON file with the filename that you defined in JSON_FILE. Remember that you’ll need to adapt the value of JSON_FILE to match the filename of your JSON file, which will be different.

Reading the file with json.load() gives you back a plain dictionary rather than the library’s response object, so you use square brackets instead of dot notation to get to the data. The script then fetches each Base64-encoded string from the "data" list, decodes it, and saves the resulting image data as a PNG file in a directory. Python will even create that directory for you, if necessary.

Note that this script will also work if you’re fetching more than one image at a time. The for loop will decode each image and save it as a new file.

Most of the code in this script handles reading and writing files in the correct directories. You already met the star of the snippet, b64decode(). You import the function in line 2 and put it to work in line 15, where it decodes each Base64-encoded string so that you can save the image data as a PNG file.

Note that the .png suffix is hard-coded, so the script is designed for responses in the default PNG format. Decoding gives you whatever bytes OpenAI produced, and it doesn’t convert between formats. If you generated the images with output_format set to "webp" or "jpeg", then change the suffix to match.

After running the script, you can head into the newly created folder structure and open the PNG file to see what your more detailed prompt produced:

Is it everything you’ve ever hoped for? If so, then rejoice! However, if the image you got looks kind of like what you’re looking for but not quite, then you can make another call to the API where you pass your image back in and ask the model to change it.