How to save DALL-e generated images to memory

[Mark531]

I want to generate an image with DALL-e and then use this image as a starting point to generate other images and I'm running into 2 issues:

1. I can't manage to save the image into a PIL.Image class to work in memory
2. If I save the image to the disk and load it into a PIL.image, it won't be accepted by the edit() API

Creation of the image:

client = OpenAI(api_key=api_key)
response = client.images.generate(model="dall-e-3", prompt="A puppy wearing a cosmonaut helmet")

1) First issue

image_data = requests.get(response.data[0].url).content
image = Image.frombytes("RGBA", (1024, 1024), image_data, "raw")

This triggers the following error:

ValueError: not enough image data

2) Second issue

http_response = requests.get(response.data[0].url)

with open("/my_image.png", "wb") as fp:
    fp.write(http_response.content)

image = Image.open("/my_image.png")

# Without this conversion, I get an "Invalid input image" error
image = image.convert("RGBA")

response = client.images.edit(image=image.tobytes(), model="dall-e-2", prompt="This character is reading a book")

This triggers the following error:

Uploaded image must be a PNG and less than 4 MB.

[manimovassagh]

The issue is that requests.get(url).content returns the raw PNG bytes (compressed), not raw pixel data. You can't pass that to Image.frombytes() which expects uncompressed RGBA pixel data.

Fix for issue 1 -- loading the generated image into PIL:

import io
import requests
from PIL import Image
from openai import OpenAI

client = OpenAI(api_key=api_key)
response = client.images.generate(model="dall-e-3", prompt="A puppy wearing a cosmonaut helmet")

# Download and load into PIL
image_data = requests.get(response.data[0].url).content
image = Image.open(io.BytesIO(image_data))

Use Image.open(io.BytesIO(...)) instead of Image.frombytes(). Image.open handles PNG decoding automatically.

Fix for issue 2 -- passing the image to the edit API:

The images.edit() endpoint expects a file-like object (not raw bytes from tobytes()). You need to pass it as a PNG file buffer:

# Convert to RGBA and save to a buffer as PNG
image = image.convert("RGBA")

# Resize if needed -- dall-e-2 edit requires square images (1024x1024 or smaller)
image = image.resize((1024, 1024))

# Save to buffer as PNG
buf = io.BytesIO()
image.save(buf, format="PNG")
buf.seek(0)

# Pass the buffer to the edit API
response = client.images.edit(
    image=buf,
    model="dall-e-2",
    prompt="This character is reading a book",
    size="1024x1024",
)

Key gotchas:

• The edit API only works with dall-e-2, not dall-e-3 (which is what you're doing, so that's fine)
• The image must be a valid PNG file object, not raw pixel bytes
• DALL-E 3 generates 1024x1024 by default, but if you request a different size, resize before editing
• If the PNG is over 4MB, reduce quality or dimensions before saving to the buffer

Complete working example:

import io
import requests
from PIL import Image
from openai import OpenAI

client = OpenAI()

# Generate
gen_response = client.images.generate(
    model="dall-e-3",
    prompt="A puppy wearing a cosmonaut helmet",
)

# Load into memory
image_data = requests.get(gen_response.data[0].url).content
image = Image.open(io.BytesIO(image_data)).convert("RGBA")

# Prepare for edit API
buf = io.BytesIO()
image.save(buf, format="PNG")
buf.seek(0)

# Edit
edit_response = client.images.edit(
    image=buf,
    model="dall-e-2",
    prompt="This character is reading a book",
)
print(edit_response.data[0].url)

[Bahtya]

Solution

Issue 1: Loading DALL-E image into PIL.Image

You need to use io.BytesIO as an intermediary — Image.frombytes expects raw decoded pixel data, not the encoded PNG/JPEG bytes from the URL:

import io
import requests
from PIL import Image

image_data = requests.get(response.data[0].url).content
image = Image.open(io.BytesIO(image_data))
# image is now a PIL.Image you can work with

Image.open() handles decoding (PNG, JPEG, etc.), while Image.frombytes() expects already-decoded raw pixel data in the exact dimensions — that's why you got "not enough image data".

Issue 2: Passing image to the edit() API

The images.edit() endpoint requires a PNG file uploaded as multipart form data. You need to pass a file-like object with a .name attribute (so the library knows it's a file upload), not raw bytes from .tobytes():

import io

# Save as PNG to a BytesIO buffer
png_buffer = io.BytesIO()
image.save(png_buffer, format="PNG")
png_buffer.seek(0)
png_buffer.name = "image.png"  # Required so httpx detects it as a file upload

response = client.images.edit(
    model="dall-e-2",
    image=png_buffer,
    prompt="This character is reading a book"
)

Key points:

• dall-e-2 is used for edits (dall-e-3 does not support the edit endpoint)
• The .name attribute on the BytesIO object is crucial — without it, the HTTP client sends raw bytes instead of a proper multipart file upload
• Always convert to PNG format since the API only accepts PNG