Editar imágenes existentes (inpainting, outpainting)
En esta página
Actualizado el 2 de noviembre de 2026 — Modelos de imagen.
gpt-image-1, el modelo para el que se escribió originalmente este curso, quedó obsoleto el 23 de octubre de 2026. Además,gpt-image-1.5,gpt-image-1-miniychatgpt-image-latestse retirarán el 1 de diciembre de 2026. Los ejemplos ahora utilizangpt-image-2.5-sunburst, que ofrece la mayor precisión para la edición;gpt-image-2.5-flarees más rápido para la generación general. Ambos modelos también admiten los ajustes de calidadxhighymax. Los modelos GPT Image devuelven siempre las imágenes en base64: el parámetroresponse_formatutilizado por los modelos DALL·E anteriores ya no se acepta y se ha eliminado del código. Fuente: Generación de imágenes (OpenAI).
Editar imágenes existentes
El método client.images.edit() modifica una imagen existente utilizando una máscara para definir el área que se debe regenerar. Esto da lugar a dos casos de uso distintos, que conviene nombrar con precisión porque requieren máscaras diferentes. El inpainting rellena o sustituye un área interior; podrías cambiar el cielo en un paisaje, la pantalla de un ordenador o el color de una pared. El outpainting, por el contrario, extiende la imagen más allá de sus bordes originales, como convertir un retrato cuadrado en un pancarta panorámica.
Cómo funciona la máscara
La máscara es una imagen PNG con las mismas dimensiones que la imagen de origen. Las áreas transparentes (alfa = 0) indican dónde debe generar nuevo contenido el modelo; las áreas opacas permanecen intactas. Esta convención resulta contraintuitiva al principio: naturalmente quieres «pintar» lo que quieres cambiar, pero en realidad necesitas recortar un agujero en la máscara. La llamada a la API en sí sigue siendo sencilla y solo requiere los dos archivos y una descripción de lo que debe aparecer.
import base64
from openai import OpenAI
client = OpenAI()
response = client.images.edit(
model="gpt-image-2.5-sunburst",
image=open("desk_photo.png", "rb"),
mask=open("desk_mask.png", "rb"),
prompt="Una pantalla de ordenador que muestra un panel de análisis moderno"
)
with open("edited_desk.png", "wb") as f:
f.write(base64.b64decode(response.data[0].b64_json))
No necesitas un editor gráfico para crear esta máscara. Pillow puede generar una en pocas líneas: comienza con una capa totalmente opaca que coincida con las dimensiones de origen y, a continuación, dibuja la forma que quieres hacer transparente. El script siguiente crea una ventana rectangular en el centro de la imagen.
from PIL import Image, ImageDraw
# Cargar la imagen de origen para obtener sus dimensiones
source = Image.open("desk_photo.png")
width, height = source.size
# Crear una máscara totalmente opaca (negra)
mask = Image.new("RGBA", (width, height), (0, 0, 0, 255))
draw = ImageDraw.Draw(mask)
# Dibujar un área transparente (el área a editar)
# Rectángulo en el centro de la imagen
x1, y1 = width // 4, height // 4
x2, y2 = 3 * width // 4, 3 * height // 4
draw.rectangle([x1, y1, x2, y2], fill=(0, 0, 0, 0))
mask.save("desk_mask.png")
print(f"Máscara creada: {width}x{height}, área editable en el centro")
Inpainting: Sustituir un elemento
Una vez que repites esta operación, tiene sentido encapsular la creación de la máscara y la llamada a la API en una única función, parametrizada por la región a modificar. El prompt debe describir entonces solo el contenido esperado dentro del área enmascarada, nunca el resto de la imagen. El ejemplo siguiente aplica esta función a una fotografía de paisaje, modificando solo los 400 píxeles superiores —el cielo— para darle una atmósfera tormentosa.
from openai import OpenAI
from PIL import Image, ImageDraw
import base64
client = OpenAI()
def inpaint_region(image_path, region, prompt, output_path):
"""
Sustituir una región rectangular en una imagen.
region: tupla (x1, y1, x2, y2) en píxeles
"""
# Crear la máscara
source = Image.open(image_path)
mask = Image.new("RGBA", source.size, (0, 0, 0, 255))
draw = ImageDraw.Draw(mask)
draw.rectangle(region, fill=(0, 0, 0, 0))
mask.save("temp_mask.png")
# Llamar a la API
response = client.images.edit(
model="gpt-image-2.5-sunburst",
image=open(image_path, "rb"),
mask=open("temp_mask.png", "rb"),
prompt=prompt
)
# Guardar el resultado
with open(output_path, "wb") as f:
f.write(base64.b64decode(response.data[0].b64_json))
print(f"Imagen editada guardada: {output_path}")
# Ejemplo: Sustituir el cielo en una foto de paisaje
inpaint_region(
image_path="landscape.png",
region=(0, 0, 1024, 400), # Parte superior = el cielo
prompt="Cielo dramático con nubes de tormenta púrpuras al atardecer",
output_path="landscape_sky_edited.png"
)
Outpainting: Extender la imagen
Ampliar una imagen requiere un paso adicional porque la API no puede generar contenido «al lado» de un archivo directamente. Primero debes crear un lienzo más grande, pegar el original sobre él y proporcionar una máscara que proteja exactamente el área ocupada por ese original. Toda la lógica depende de calcular las nuevas dimensiones y la posición de pegado en función de la dirección solicitada.
from openai import OpenAI
from PIL import Image
import base64
from io import BytesIO
client = OpenAI()
def outpaint(image_path, direction, extra_pixels, prompt, output_path):
"""
Extender una imagen en una dirección dada.
direction: 'right', 'bottom', 'left', 'top'
extra_pixels: número de píxeles a añadir
"""
source = Image.open(image_path).convert("RGBA")
w, h = source.size
# Calcular nuevas dimensiones
if direction == "right":
new_size = (w + extra_pixels, h)
paste_pos = (0, 0)
elif direction == "bottom":
new_size = (w, h + extra_pixels)
paste_pos = (0, 0)
elif direction == "left":
new_size = (w + extra_pixels, h)
paste_pos = (extra_pixels, 0)
elif direction == "top":
new_size = (w, h + extra_pixels)
paste_pos = (0, extra_pixels)
# Crear el lienzo extendido (transparente = área a generar)
extended = Image.new("RGBA", new_size, (0, 0, 0, 0))
extended.paste(source, paste_pos)
# La máscara: transparente en todas partes excepto donde se coloca la imagen original
mask = Image.new("RGBA", new_size, (0, 0, 0, 0))
opaque = Image.new("RGBA", (w, h), (0, 0, 0, 255))
mask.paste(opaque, paste_pos)
# Guardar temporalmente
extended.save("temp_extended.png")
mask.save("temp_mask_outpaint.png")
response = client.images.edit(
model="gpt-image-2.5-sunburst",
image=open("temp_extended.png", "rb"),
mask=open("temp_mask_outpaint.png", "rb"),
prompt=prompt
)
with open(output_path, "wb") as f:
f.write(base64.b64decode(response.data[0].b64_json))
print(f"Imagen extendida guardada: {output_path}")
# Extender un retrato hacia la derecha
outpaint(
image_path="portrait.png",
direction="right",
extra_pixels=512,
prompt="Continuación natural de la escena, misma iluminación y fondo",
output_path="portrait_extended.png"
)
Observa la redacción del prompt de extensión: «continuación natural de la escena, misma iluminación y fondo». En el outpainting, no describes un nuevo sujeto; pides al modelo que extienda lo que ya ve. Un prompt excesivamente creativo produciría una costura visible entre el original y el área añadida.
Edición iterativa
Nada te impide encadenar varias ediciones sobre la misma imagen, utilizando cada salida como entrada para el siguiente paso. Esta es la forma más fiable de construir una composición compleja: ocupa primero el fondo y luego el primer plano, con una máscara dedicada para cada pasada, en lugar de esperar que un único prompt lo arregle todo de una vez.
import base64
from openai import OpenAI
client = OpenAI()
def edit_step(image_path, mask_path, prompt, output_path):
response = client.images.edit(
model="gpt-image-2.5-sunburst",
image=open(image_path, "rb"),
mask=open(mask_path, "rb"),
prompt=prompt
)
with open(output_path, "wb") as f:
f.write(base64.b64decode(response.data[0].b64_json))
return output_path
# Paso 1: Modificar el fondo
step1 = edit_step(
"scene.png", "mask_background.png",
"Fondo de selva tropical frondosa",
"scene_step1.png"
)
# Paso 2: Añadir un elemento al primer plano
step2 = edit_step(
step1, "mask_foreground.png",
"Un loro guacamayo de colores posado en una rama",
"scene_step2.png"
)
print(f"Resultado final: {step2}")
Restricciones clave
Cuatro reglas técnicas gobiernan el éxito de la llamada. Violar cualquiera de ellas provoca un error inmediato en lugar de un resultado degradado.
- La imagen de origen y la máscara deben tener las mismas dimensiones
- Ambos archivos deben estar en formato PNG
- El tamaño máximo por archivo es de 4 MB
- La máscara utiliza el canal alfa para definir las áreas editables
Una observación empírica se suma a estas restricciones: los resultados son más consistentes cuando el área enmascarada representa menos del 50 % de la imagen. Más allá de ese punto, el modelo tiene demasiado poco contexto para fundir correctamente la imagen y, a menudo, obtendrás mejores resultados si divides tu modificación en dos ediciones sucesivas.
Pon esto en práctica con una foto de tu escritorio o cualquier imagen libre de derechos: escribe un script que genere automáticamente una máscara sobre el cuarto superior de la imagen, sustituya esa área por un cielo estrellado y guarde el resultado localmente.