Guía práctica de 9 pasos para integrar gpt-image-2 con la API oficial: de cero a producción

El modelo gpt-image-2, lanzado por OpenAI en abril de 2026, se ha convertido en la referencia absoluta en el sector de la generación de imágenes: una precisión de renderizado de texto a nivel de carácter del 99 %, salida en alta definición 4K, soporte nativo para chino/CJK e integración de las capacidades de razonamiento de la serie O. Sin embargo, la primera pregunta que se hacen muchos desarrolladores al obtener acceso es: ¿Cómo se integra realmente gpt-image-2 en la API oficial? ¿Qué parámetros son obligatorios? ¿Cómo se configura la base_url? ¿Qué hacer con el b64_json que devuelve la respuesta?

Este artículo es una guía práctica de integración de la API oficial de gpt-image-2 de extremo a extremo, que cubre todos los detalles técnicos desde la instalación del SDK y la configuración de la base_url hasta la generación de imágenes (texto a imagen), edición, inpainting y manejo de errores. Todo el código se basa en el SDK oficial de OpenAI y el canal de tránsito oficial de APIYI (100 % compatible con los campos oficiales). Tras completar este artículo, tu proyecto estará listo para utilizar gpt-image-2 en un entorno de producción.

Lista de preparación para integrar la API oficial de gpt-image-2

Antes de escribir la primera línea de código, debes preparar el entorno. La siguiente lista cubre los 4 requisitos previos necesarios para integrar gpt-image-2 en la API oficial.

Lista de verificación del entorno para la API de gpt-image-2

Elemento	Requisito	Descripción
Clave API	Bearer Token válido	Solicítala a través del panel de control de APIYI; regístrate para obtener crédito de prueba
SDK de Python	`openai >= 1.50.0`	Las versiones antiguas no admiten los nuevos parámetros de `images.generate()`
SDK de Node.js	`openai >= 4.50.0`	Los tipos de TypeScript ya están sincronizados con los oficiales
Tiempo de espera HTTP	≥ 360 segundos	La calidad "high" + 2K/4K tarda entre 3 y 5 minutos en procesarse
Requisitos de red	Conexión directa desde cualquier lugar	`api.apiyi.com` es accesible desde redes domésticas, locales o internacionales

Instalación del SDK para la API de gpt-image-2

Independientemente del lenguaje que elijas, solo necesitas instalar el SDK oficial de OpenAI; el canal de tránsito de APIYI es totalmente coherente con los campos oficiales, por lo que no se requieren bibliotecas de cliente adicionales.

# Python
pip install --upgrade openai

# Node.js
npm install openai@latest

# Si usas yarn / pnpm
yarn add openai
pnpm add openai

Proceso de obtención de la clave API para gpt-image-2

Los pasos para obtener la clave API son extremadamente sencillos:

Visita el panel de control de APIYI en api.apiyi.com.
Tras registrar tu cuenta, accede a la página de "Tokens de API".
Crea un nuevo token (se recomienda usar un token independiente para cada proyecto para facilitar la auditoría).
Guarda el token en una variable de entorno (se desaconseja encarecidamente codificarlo directamente en el código).

🚀 Consejo de inicio rápido: Al integrar la API oficial de gpt-image-2 por primera vez, se recomienda probar primero con baja calidad y 1024×1024 para verificar el enlace, antes de cambiar a alta calidad y grandes dimensiones. Sugerimos obtener crédito de prueba a través de la plataforma APIYI (apiyi.com), ya que el crédito gratuito es suficiente para completar todo el proceso de validación PoC.

# Añadir a ~/.zshrc o ~/.bashrc
export APIYI_KEY="sk-tu-token-aqui"

Configuración de `base_url` para integrar `gpt-image-2` con la API oficial

En todo el proceso de integración de gpt-image-2 con la API oficial, lo único que difiere del SDK nativo de OpenAI es la base_url. Simplemente cámbiala de api.openai.com a api.apiyi.com y mantén el resto del código exactamente igual.

Dos endpoints para integrar `gpt-image-2` con la API oficial

APIYI ofrece dos endpoints de imagen totalmente compatibles con OpenAI:

Endpoint	Uso	Parámetros requeridos
`POST /v1/images/generations`	Generación de imágenes (solo por indicación)	`model`, `prompt`
`POST /v1/images/edits`	Edición de imágenes, fusión, repintado con máscara	`model`, `prompt`, `image`

Inicialización del cliente para `gpt-image-2`

A continuación, te presento el código de inicialización para Python y Node.js. Recuerda configurar el tiempo de espera (timeout) a más de 360 segundos.

# Python
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("APIYI_KEY"),
    base_url="https://api.apiyi.com/v1",  # Cambiar al canal de proxy de APIYI
    timeout=600.0,                         # Imprescindible para alta resolución
    max_retries=2
)

// Node.js
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.APIYI_KEY,
  baseURL: "https://api.apiyi.com/v1",  # Nota: baseURL (camelCase)
  timeout: 600 * 1000,                  # En milisegundos
  maxRetries: 2
});

💡 Recordatorio sobre el tiempo de espera: El valor predeterminado de 60 segundos fallará inevitablemente en escenarios de alta calidad (high) + 2K/4K. Recomendamos que, al integrar a través de APIYI (apiyi.com), establezcas el tiempo de espera de todas las solicitudes en entornos de producción entre 360 y 600 segundos para evitar que las peticiones de larga duración se interrumpan erróneamente.

Invocación de generación de imágenes con `gpt-image-2`

Pasemos a la práctica. A continuación, te muestro cómo realizar la primera llamada de generación de imágenes con gpt-image-2 en tres lenguajes.

Generación de imágenes con Python

import base64
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("APIYI_KEY"),
    base_url="https://api.apiyi.com/v1",
    timeout=600.0
)

response = client.images.generate(
    model="gpt-image-2",
    prompt="A modern minimalist office desk with a vintage typewriter, soft morning light from the window, photorealistic, 8K",
    size="1536x1024",
    quality="high",
    output_format="jpeg",
    output_compression=92,
    n=1
)

# Clave: APIYI devuelve una cadena base64 pura, sin el prefijo data:image/...
b64 = response.data[0].b64_json
with open("output.jpg", "wb") as f:
    f.write(base64.b64decode(b64))

print("✓ Imagen guardada en output.jpg")

Generación de imágenes con Node.js

import fs from "node:fs/promises";
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.APIYI_KEY,
  baseURL: "https://api.apiyi.com/v1",
  timeout: 600_000
});

const response = await client.images.generate({
  model: "gpt-image-2",
  prompt: "An e-commerce product photo of a leather backpack on a marble desk, studio lighting",
  size: "1024x1024",
  quality: "high",
  output_format: "png",
  n: 1
});

const b64 = response.data[0].b64_json;
await fs.writeFile("output.png", Buffer.from(b64, "base64"));
console.log("✓ Imagen guardada");

Generación de imágenes con cURL

cURL es ideal para verificar rápidamente la disponibilidad de tu clave API y probar nuevas combinaciones de parámetros.

curl https://api.apiyi.com/v1/images/generations \
  -H "Authorization: Bearer $APIYI_KEY" \
  -H "Content-Type: application/json" \
  --max-time 600 \
  -d '{
    "model": "gpt-image-2",
    "prompt": "A futuristic cyberpunk city at night, neon signs in mixed Chinese and English",
    "size": "2048x1152",
    "quality": "high",
    "output_format": "jpeg",
    "output_compression": 90,
    "n": 1
  }' | jq -r '.data[0].b64_json' | base64 -d > output.jpg

Asegúrate de incluir --max-time 600, ya que cURL no tiene tiempo de espera por defecto, pero muchos envoltorios de shell añaden una interrupción forzada a los 60 segundos.

Puntos clave sobre el manejo de la respuesta

Muchos desarrolladores se quedan atascados en el análisis de base64 durante su primera integración. Aquí tienes algunos errores comunes:

# ✗ Error: APIYI no devuelve el campo url
url = response.data[0].url  # AttributeError

# ✓ Correcto: usar b64_json
b64 = response.data[0].b64_json

# ✗ Error: el navegador no renderiza directamente la cadena b64 pura
<img src="{b64}">  # No se mostrará

# ✓ Correcto: el navegador necesita el prefijo concatenado manualmente
data_uri = f"data:image/jpeg;base64,{b64}"
# <img src="{{ data_uri }}">

# ✓ Correcto: guardar en disco desde el servidor
with open("output.jpg", "wb") as f:
    f.write(base64.b64decode(b64))

Análisis detallado de los parámetros para integrar la API oficial de gpt-image-2

Dominar el rango de valores y los escenarios de aplicación de cada parámetro es fundamental para llevar la integración de la API oficial de gpt-image-2 a un entorno de producción.

Tabla de parámetros principales para la integración de la API oficial de gpt-image-2

Parámetro	Valor	Valor predeterminado	Descripción
`model`	`"gpt-image-2"`	Obligatorio	ID del modelo
`prompt`	Cadena de texto	Obligatorio	Indicación, admite mezcla de chino e inglés
`size`	8 preajustes + personalizado	`auto`	Ver tabla a continuación
`quality`	`auto` / `low` / `medium` / `high`	`auto`	Afecta el costo y el tiempo de procesamiento
`output_format`	`png` / `jpeg` / `webp`	`png`	Se recomienda jpeg + 90 de compresión
`output_compression`	1-100	100	Solo efectivo para jpeg/webp
`moderation`	`auto` / `low`	`auto`	`low` reduce la sensibilidad de la moderación
`n`	1-10	1	Cantidad de imágenes por generación

Opciones completas del parámetro `size` para la API oficial de gpt-image-2

# 8 preajustes oficiales
size = "1024x1024"   # 1:1 Cuadrado estándar
size = "1536x1024"   # 3:2 Horizontal
size = "1024x1536"   # 2:3 Vertical
size = "2048x2048"   # 2K Cuadrado
size = "2048x1152"   # 16:9 Horizontal (ideal para fondos de pantalla/carteles)
size = "3840x2160"   # 4K Horizontal
size = "2160x3840"   # 4K Vertical (ideal para fondos de pantalla móviles)
size = "auto"        # Selección automática por el modelo

Si necesitas dimensiones personalizadas, debes cumplir con las siguientes restricciones:

✓ La longitud del lado debe ser múltiplo de 16
✓ La longitud máxima del lado ≤ 3840px
✓ La relación de aspecto entre lados largos y cortos ≤ 3:1
✓ El total de píxeles debe estar entre 655,360 y 8,294,400

Por ejemplo, 1280x720 (720P) es válido, mientras que 3840x1080 (pantalla ultra ancha) será rechazado por tener una relación > 3:1.

Comparativa de `quality` y costos para la API oficial de gpt-image-2

El parámetro quality es el que más afecta el costo. A continuación, la tabla de precios completa (por imagen).

Calidad	1024×1024	1024×1536	1536×1024	Escenario de uso
`low`	$0.006	$0.005	$0.005	Bocetos, miniaturas, iteración rápida
`medium`	$0.053	$0.041	$0.041	Sitios de contenido, imágenes para redes sociales
`high`	$0.211	$0.165	$0.165	Imágenes de productos, carteles, material publicitario

💰 Optimización de costos: Los equipos de contenido que generan 100 imágenes al día pueden ahorrar un 75% en costos usando la calidad medium en lugar de high. Recomendamos usar la plataforma APIYI (apiyi.com) para probar y ajustar la indicación rápidamente con calidad low, y una vez definida, subir a medium/high para obtener la imagen final. Esto puede reducir el presupuesto mensual de generación de imágenes entre un 30% y un 50%.

Selección de `output_format` para la API oficial de gpt-image-2

El formato de salida afecta directamente los costos de almacenamiento y la velocidad de carga:

# ¿Necesitas fondo transparente? gpt-image-2 no lo admite, devolverá un error 400
# ✗ output_format="png", background="transparent" → 400 Bad Request

# Visualización en web/mini programas: jpeg + compresión 90
output_format="jpeg", output_compression=90

# Archivo de alta fidelidad: png (sin pérdida)
output_format="png"

# Aplicaciones web modernas: webp tiene el tamaño más pequeño
output_format="webp", output_compression=85

Edición de imágenes e Inpainting con la API oficial de gpt-image-2

Además de la generación de texto a imagen, gpt-image-2 también admite tres escenarios de edición clave: edición de imágenes, fusión de múltiples imágenes y repintado local (inpainting/outpainting).

Edición de imágenes con gpt-image-2 mediante la API oficial (modo de imagen de referencia)

La edición con imagen de referencia activa automáticamente el modo de alta fidelidad, por lo que no debes pasar el parámetro input_fidelity (será rechazado).

from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("APIYI_KEY"),
    base_url="https://api.apiyi.com/v1"
)

# Edición con una sola imagen de referencia
with open("source.jpg", "rb") as img:
    response = client.images.edit(
        model="gpt-image-2",
        image=img,
        prompt="Cambia el fondo a una playa al atardecer, manteniendo la postura y la ropa del personaje en primer plano",
        size="1024x1024",
        quality="high"
    )

Fusión de múltiples imágenes con gpt-image-2 mediante la API oficial (hasta 16 imágenes)

El endpoint /images/edits admite la entrada simultánea de hasta 16 imágenes de referencia; en el prompt, puedes referirte a ellas como "Imagen 1/Imagen 2/Imagen 3".

images = [
    open("character.jpg", "rb"),     # Imagen 1: Personaje
    open("background.jpg", "rb"),    # Imagen 2: Fondo
    open("outfit.jpg", "rb"),        # Imagen 3: Referencia de ropa
]

response = client.images.edit(
    model="gpt-image-2",
    image=images,
    prompt="Coloca al personaje de la Imagen 1 en el fondo de la Imagen 2, haz que el personaje vista el estilo de ropa de la Imagen 3, manteniendo una calidad cinematográfica",
    size="2048x1152",
    quality="high"
)

Esta capacidad es extremadamente poderosa para escenarios como el cambio de fondo de productos de comercio electrónico, pruebas virtuales de ropa y la generación de guiones gráficos para cómics.

Inpainting (repintado local) con gpt-image-2 mediante la API oficial

El Inpainting utiliza el parámetro mask para especificar el área que se desea repintar. Reglas clave:

La máscara debe tener la misma dimensión que la primera imagen de referencia.
La máscara debe ser un PNG con canal alfa.
Área transparente = área a repintar.
Área opaca = mantener la imagen original.

with open("photo.png", "rb") as img, open("mask.png", "rb") as msk:
    response = client.images.edit(
        model="gpt-image-2",
        image=img,
        mask=msk,
        prompt="Cambia el área del recuadro rojo por un gato naranja",
        size="1024x1024",
        quality="high"
    )

Si necesitas generar la máscara mediante programación en Python, puedes usar PIL:

from PIL import Image

# Crear una máscara con las mismas dimensiones que la imagen original, por defecto todo negro (opaco = mantener)
mask = Image.new("RGBA", (1024, 1024), (0, 0, 0, 255))

# Cambiar el área a repintar a transparente (alfa=0)
for x in range(400, 700):
    for y in range(300, 600):
        mask.putpixel((x, y), (0, 0, 0, 0))

mask.save("mask.png")

Gestión de errores y mejores prácticas de producción para la integración de la API oficial de gpt-image-2

Llevar la integración de gpt-image-2 con la API oficial a un entorno de producción requiere gestionar correctamente tres pilares fundamentales: códigos de error, concurrencia y tiempos de espera (timeouts).

Tabla completa de códigos de error para la API de gpt-image-2

Código de estado HTTP	Significado	Acción recomendada
`400`	Parámetros inválidos (tamaño fuera de rango, campos no soportados)	Validar entrada; no enviar `input_fidelity` o `background:transparent`
`401`	Token inválido	Verificar el Bearer Token y confirmar que no haya expirado
`403`	Bloqueo por moderación de contenido	Ajustar la indicación o añadir `moderation: "low"`
`429`	Límite de tasa / Saldo insuficiente	Reintento con retroceso exponencial + verificar saldo
`5xx`	Error de puerta de enlace o backend	Reintentar 1-2 veces; si persiste, enviar alerta
Timeout	Solicitud de larga duración sin respuesta	Configurar el timeout del cliente a ≥ 360 segundos

Reintento con retroceso exponencial para la API de gpt-image-2

A continuación, presento una implementación de reintento de nivel profesional que gestiona los errores 429 y 5xx:

import time
import random
from openai import OpenAI, RateLimitError, APIStatusError

client = OpenAI(
    api_key=os.getenv("APIYI_KEY"),
    base_url="https://api.apiyi.com/v1",
    timeout=600.0
)

def generate_with_retry(prompt: str, max_retries: int = 5):
    delay = 1.0
    for attempt in range(max_retries):
        try:
            return client.images.generate(
                model="gpt-image-2",
                prompt=prompt,
                size="1024x1024",
                quality="high"
            )
        except RateLimitError:
            sleep = delay + random.uniform(0, 0.5)
            print(f"429 Límite de tasa, reintentando en {sleep:.1f}s ({attempt+1}/{max_retries})")
            time.sleep(sleep)
            delay *= 2
        except APIStatusError as e:
            if 500 <= e.status_code < 600 and attempt < max_retries - 1:
                time.sleep(delay)
                delay *= 2
                continue
            raise
    raise RuntimeError("Se superó el número máximo de reintentos")

Control de concurrencia para la API de gpt-image-2

Para tareas por lotes, utiliza asyncio.Semaphore para limitar la concurrencia y evitar saturar el servicio:

import asyncio
from openai import AsyncOpenAI

aclient = AsyncOpenAI(
    api_key=os.getenv("APIYI_KEY"),
    base_url="https://api.apiyi.com/v1",
    timeout=600.0
)

async def gen_one(prompt: str, sem: asyncio.Semaphore):
    async with sem:
        return await aclient.images.generate(
            model="gpt-image-2",
            prompt=prompt,
            size="1024x1024",
            quality="medium"
        )

async def batch(prompts: list[str], concurrency: int = 30):
    sem = asyncio.Semaphore(concurrency)
    return await asyncio.gather(*[gen_one(p, sem) for p in prompts])

# Generar 200 imágenes, 30 peticiones concurrentes
prompts = [f"Variante de imagen de producto #{i}" for i in range(200)]
results = asyncio.run(batch(prompts))

Estimación de costes para la API de gpt-image-2

Antes de pasar a producción, realiza una estimación de costes. Aquí tienes ejemplos de escenarios típicos:

Escenario de negocio	Volumen diario	Calidad	Coste mensual estimado
Imágenes para redes sociales	30 uds.	medium	~$48
Imágenes de productos (e-commerce)	200 uds.	high	~$1266
Generación de imágenes SaaS	1000 veces	medium	~$1590
Fotogramas clave para juegos	500 uds.	high	~$3165

🎯 Consejo de despliegue: Recomendamos solicitar claves API independientes para cada línea de negocio para facilitar la atribución de costes y el aislamiento de límites. Sugerimos configurar alertas de facturación en el panel de control de APIYI (apiyi.com) para recibir notificaciones automáticas al alcanzar umbrales predefinidos y evitar sobrecostes.

Observabilidad para la API de gpt-image-2

En entornos de producción, es fundamental registrar las métricas clave de cada solicitud:

import time
import logging

logger = logging.getLogger("gpt-image-2")

def call_with_metrics(prompt: str, **params):
    start = time.perf_counter()
    try:
        resp = client.images.generate(model="gpt-image-2", prompt=prompt, **params)
        latency = time.perf_counter() - start
        logger.info(
            "gpt-image-2 ok",
            extra={
                "latency_ms": int(latency * 1000),
                "size": params.get("size"),
                "quality": params.get("quality"),
                "n": params.get("n", 1)
            }
        )
        return resp
    except Exception as e:
        logger.error(f"gpt-image-2 fallido: {type(e).__name__}: {e}")
        raise

Preguntas frecuentes (FAQ) sobre la integración de gpt-image-2

P1: ¿Por qué recibo un error 400 con `input_fidelity` al usar gpt-image-2?

gpt-image-2 activa automáticamente la alta fidelidad en todos los escenarios de edición, por lo que el parámetro input_fidelity es rechazado. Simplemente elimínalo. Si migraste tu código desde gpt-image-1, realiza una búsqueda global para quitarlo. Recomendamos consultar la documentación de APIYI (apiyi.com) para comparar las diferencias de parámetros entre modelos: docs.apiyi.com.

P2: ¿Por qué las llamadas a la API de gpt-image-2 suelen agotar el tiempo de espera?

La generación en calidad "high" con tamaños 2K/4K puede tardar entre 3 y 5 minutos. Si el timeout predeterminado de tu cliente es de 60 segundos, fallará inevitablemente. Solución: Configura el timeout entre 360 y 600 segundos. En el SDK de Python usa OpenAI(timeout=600), en Node.js timeout: 600_000 y en cURL --max-time 600.

P3: ¿Cómo mostrar el `b64_json` devuelto por la API directamente en la web?

La API devuelve una cadena base64 pura sin prefijo, por lo que el navegador no puede renderizarla directamente. Debes concatenar el formato:

const dataUri = `data:image/${format};base64,${b64}`;
imgElement.src = dataUri;

Si es un servicio backend, recomendamos decodificar el base64 y guardarlo en un OSS/CDN, enviando al frontend solo la URL para evitar que las cadenas base64 ralenticen la carga inicial. Recomendamos probar primero con cURL y decodificar a un archivo local mediante la plataforma APIYI (apiyi.com) antes de implementar la arquitectura de almacenamiento.

P4: ¿Se puede obtener un fondo transparente con gpt-image-2?

Actualmente, gpt-image-2 no soporta fondos transparentes; enviar background: "transparent" resultará en un error 400. Alternativa: genera la imagen con fondo blanco/verde y utiliza herramientas de cliente (como la librería rembg) para eliminar el fondo.

P5: ¿Cómo utilizar el parámetro `thinking` en gpt-image-2?

thinking es un parámetro de razonamiento introducido en gpt-image-2 (off / low / medium / high). Al activarlo, el modelo planifica la composición antes de generar, lo que mejora la calidad pero aumenta significativamente el coste (el modo high cuesta entre 4 y 5 veces más). Consejo: Úsalo en modo medium solo para carteles con mucho texto o composiciones complejas; manténlo en off para casos generales. Recomendamos realizar pruebas A/B mediante la interfaz unificada de APIYI (apiyi.com) antes de activarlo permanentemente.

P6: ¿Qué hacer si recibo un error 403 de moderación de contenido?

Intenta añadir moderation: "low" en la solicitud para reducir la sensibilidad. Si el bloqueo persiste, significa que la indicación activó políticas de seguridad críticas (violencia, contenido inapropiado para menores, retratos de figuras públicas, etc.) y debes reescribir la indicación. Nota: moderation: "low" no desactiva la moderación, solo la relaja.

P7: ¿Qué sucede si escribo mal la `base_url`?

Si escribes https://api.apiyi.com (omitiendo /v1), el SDK intentará acceder a api.apiyi.com/images/generations y obtendrás un error 404. La forma correcta es https://api.apiyi.com/v1. En Python usa base_url y en Node.js baseURL (cuidado con las mayúsculas).

P8: ¿Cuál es la mejor práctica para la fusión de múltiples imágenes en gpt-image-2?

Se admiten hasta 16 imágenes de referencia, haciendo referencia a ellas en la indicación como "Imagen 1/Imagen 2". Consejos clave:

La primera imagen de referencia suele actuar como "sujeto principal"; el modelo priorizará conservar su estructura.
Para instrucciones complejas, divide el proceso: primero indica "usar la Imagen 1 como sujeto" y luego "fusionar el tono de la Imagen 2".
La edición de múltiples imágenes cuesta entre 1.5 y 2 veces más que una generación estándar; úsalo con precaución si tu presupuesto es ajustado.
Recomendamos validar la lógica con 2-3 imágenes antes de escalar a más referencias.

Resumen: Revisión completa de la integración de gpt-image-2 con la API oficial

Tras completar los 9 capítulos de este artículo, ya deberías dominar el método de ingeniería completo para integrar gpt-image-2 con la API oficial:

✅ Preparativos —— Actualización del SDK a la última versión y configuración del tiempo de espera (timeout) a ≥ 360 segundos.
✅ Configuración de base_url —— Reemplazo por https://api.apiyi.com/v1, manteniendo el resto del código igual al oficial.
✅ Invocación de texto a imagen —— Plantillas en tres lenguajes: Python, Node.js y cURL.
✅ Detalles de parámetros —— 8 tamaños preestablecidos + personalizados, 3 niveles de calidad y 3 formatos de salida.
✅ Edición de imágenes —— Hasta 16 imágenes de referencia, utilizando "img1/img2" para hacer referencia en la indicación.
✅ Inpainting (redibujado) —— Uso del canal alfa de la máscara para redibujar áreas transparentes.
✅ Manejo de errores —— Soluciones completas para códigos 400/401/403/429/5xx.
✅ Práctica de producción —— Retroceso exponencial (exponential backoff), control de concurrencia, estimación de costos y observabilidad.

Por último, un consejo para la implementación: primero ejecuta un "Hola mundo" con calidad low y resolución 1024×1024, y luego aumenta la complejidad gradualmente. Esto te permitirá detectar rápidamente problemas básicos como la versión del SDK, el tiempo de espera o la clave API, evitando perder tiempo de depuración en solicitudes complejas de alta calidad (high + 4K).

Si tu equipo está evaluando la solución de integración de gpt-image-2, o si ya estás escribiendo la primera versión del código y te encuentras con errores de parámetros o tiempos de espera, te recomendamos solicitar una clave de prueba a través de APIYI en apiyi.com para ejecutar las plantillas de código de este artículo. Todos los ejemplos se basan en el SDK oficial + el servicio proxy de API de APIYI (campos 100% compatibles), lo que garantiza una alta versatilidad que puedes aplicar directamente a tus propios proyectos.

Referencias

Documentación del modelo gpt-image-2 de OpenAI: Información oficial sobre capacidades, parámetros y precios.
- Enlace: developers.openai.com/api/docs/models/gpt-image-2
- Descripción: Incluye características clave como renderizado 4K, texto a nivel de carácter e integración de razonamiento.
Guía de generación de imágenes de OpenAI: Flujo de trabajo completo para texto a imagen, edición e inpainting.
- Enlace: developers.openai.com/api/docs/guides/image-generation
- Descripción: Cubre la explicación detallada de todos los parámetros de tamaño/calidad/formato.
Referencia de la API Create Image de OpenAI: Campos completos del endpoint /v1/images/generations.
- Enlace: developers.openai.com/api/reference/resources/images/methods/generate
- Descripción: Referencia autorizada de los campos de solicitud y respuesta.
Documentación oficial de integración de APIYI: Guía completa de integración de gpt-image-2.
- Enlace: docs.apiyi.com/api-capabilities/gpt-image-2/overview
- Descripción: Contiene ejemplos en cURL/Python/Node.js y manejo de códigos de error.
OpenAI Cookbook · Límites de tasa (Rate Limits): Estrategia de retroceso exponencial para errores 429.
- Enlace: developers.openai.com/cookbook/examples/how_to_handle_rate_limits
- Descripción: Plantilla de código recomendada oficialmente para manejar la limitación de tasa.

Autor: Equipo técnico de APIYI
Fecha de publicación: 27 de abril de 2026
Palabras clave: integración de gpt-image-2 con API oficial, base_url, texto a imagen, edición de imágenes, inpainting, APIYI, SDK de OpenAI