API de GPT Image 2.6 Flare: Generación, edición y precios

Para qué está diseñado Flare

Flare está posicionado para borradores rápidos, vistas previas frecuentes y revisiones interactivas. Los usos prácticos incluyen explorar fondos para fotos de productos, probar composiciones de campañas y generar varias direcciones visuales antes de elegir una para finalizar. GPT Image 2.6 Sunburst es la alternativa orientada al detalle y la consistencia dentro de la misma familia. No es simplemente un “modo de ilustración”, y Flare no se limita al fotorrealismo. Compáralos según los detalles que determinan la aprobación: fidelidad de la etiqueta, diseño, preservación de un sujeto aprobado y la cantidad de revisiones requeridas. Usa el catálogo de modelos para verificar la disponibilidad actual. Una cuenta compartida no hace que las entradas, las rutas de tareas o la configuración de salida de cada modelo sean idénticas.

Configura tu clave de API

Crea una clave en el panel de claves de API de GPT Proto, luego hazla disponible para tu aplicación del lado del servidor:

export GPTPROTO_API_KEY="tu_clave_de_api_aqui"

Mantén la clave fuera del código del navegador y del control de versiones. Cárgala desde una variable de entorno o desde el almacén de secretos de tu implementación. Si usas un archivo local .env, excluye ese archivo de las confirmaciones (commits). Para esta guía, el origen de la API es https://gptproto.com. Las rutas de generación y edición a continuación ya contienen /api/v3; no antepongas /v1 ni sustituyas una URL base de chat-completions. Una solicitud exitosa de lista de modelos no es prueba de que una ruta de imagen pueda completar un trabajo. Verifica el flujo completo de envío y resultado con una solicitud pequeña antes de agregar procesamiento por lotes.

Generar una imagen

La ruta de texto a imagen de Flare publica este endpoint:

POST https://gptproto.com/api/v3/openai/gpt-image-2.6-flare/text-to-image

Comienza con una imagen y configuraciones explícitas para que la solicitud sea fácil de inspeccionar:

curl --request POST \
  "https://gptproto.com/api/v3/openai/gpt-image-2.6-flare/text-to-image" \
  --header "Authorization: Bearer $GPTPROTO_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "prompt": "A square studio product photo of a matte navy insulated bottle on a pale gray plinth. Soft side lighting, warm off-white background, room for copy on the left. No text.",
    "n": 1,
    "quality": "medium",
    "size": "1024x1024",
    "enable_sync_mode": false,
    "response_format": "url"
  }'

El modelo se selecciona mediante la URL. Esta ruta publicada no requiere un campo model separado, y size es opcional en lugar de un tercer campo obligatorio.

Campos de solicitud

Recuperar el resultado

El envío y la recuperación de resultados utilizan un sobre que contiene code, message y data. Un éxito HTTP por sí solo no significa que la generación haya terminado. Verifica el code a nivel de negocio, así como el estado de la predicción.

GET https://gptproto.com/api/v3/predictions/{result_id}/result

Usa la misma autenticación Bearer al realizar el sondeo. Para response_format: "url", las salidas completadas son URLs de archivo. Para b64_json, la matriz de salida documentada puede contener cadenas Base64. Ninguno de los casos utiliza la suposición nativa de OpenAI data[0].b64_json para esta ruta de GPT Proto. Guarda los activos que necesites conservar, preserva su tipo de medio real y no dependas de una vida útil de URL alojada no documentada.

Python: Enviar y consultar

Instala requests en el entorno de tu aplicación. El siguiente ejemplo envía una solicitud, consulta la URL de resultado devuelta e imprime las URLs de salida completadas. El límite de cinco minutos es un tiempo de espera de la aplicación utilizado en este ejemplo, no una garantía del servicio.

import os
import time
from urllib.parse import urlparse
import requests
ORIGIN = "https://gptproto.com"
API_KEY = os.environ["GPTPROTO_API_KEY"]
HEADERS = {"Authorization": f"Bearer {API_KEY}"}
def read_envelope(response):
    response.raise_for_status()
    body = response.json()
    if body.get("code") != 200:
        raise RuntimeError(f"GPT Proto request failed: {body.get('message')}")
    data = body.get("data")
    if not isinstance(data, dict):
        raise RuntimeError("Missing prediction data")
    return data
def submit_and_poll(scene, payload, timeout_seconds=300):
    if scene not in {"text-to-image", "image-edit"}:
        raise ValueError("Unsupported scene")
    endpoint = f"{ORIGIN}/api/v3/openai/gpt-image-2.6-flare/{scene}"
    response = requests.post(
        endpoint,
        headers={**HEADERS, "Content-Type": "application/json"},
        json=payload,
        timeout=(10, 120),
    )
    prediction = read_envelope(response)
    prediction_id = prediction.get("id")
    deadline = time.monotonic() + timeout_seconds
    while True:
        status = prediction.get("status")
        if status == "completed":
            outputs = prediction.get("outputs")
            if not isinstance(outputs, list) or not outputs:
                raise RuntimeError("Completed prediction has no outputs")
            return outputs
        if status == "failed":
            raise RuntimeError(
                f"Prediction {prediction_id} failed: {prediction.get('error')}"
            )
        if status not in {"created", "running"}:
            raise RuntimeError(f"Unexpected prediction status: {status}")
        if time.monotonic() >= deadline:
            raise TimeoutError(f"Check prediction {prediction_id} before resubmitting")
        result_url = prediction.get("urls", {}).get("get")
        parsed = urlparse(result_url or "")
        if (
            parsed.scheme != "https"
            or parsed.netloc != "gptproto.com"
            or not parsed.path.startswith("/api/v3/predictions/")
        ):
            raise RuntimeError("Unexpected result URL; check the route documentation")
        time.sleep(2)
        prediction = read_envelope(
            requests.get(result_url, headers=HEADERS, timeout=(10, 60))
        )
if __name__ == "__main__":
    outputs = submit_and_poll(
        "text-to-image",
        {
            "prompt": "A square product photo of a navy bottle on a pale plinth, soft side lighting, no text",
            "n": 1,
            "quality": "medium",
            "size": "1024x1024",
            "enable_sync_mode": False,
            "response_format": "url",
        },
    )
    for output_url in outputs:
        print(output_url)

Guarda el script como flare_example.py si deseas reutilizar su asistente en el ejemplo de edición a continuación. Se detiene intencionalmente ante errores de solicitud en lugar de reenviar automáticamente una generación potencialmente facturable. Agrega un manejo de reintentos en producción alrededor de la operación correspondiente después de verificar si la predicción original existe.

Node.js: Enviar una generación

Con un entorno de ejecución de Node.js actual que sea compatible con fetch y AbortSignal.timeout, puedes enviar el mismo JSON sin un contenedor de imagen específico del SDK. Guarda este ejemplo como un archivo .mjs:

const apiKey = process.env.GPTPROTO_API_KEY;
if (!apiKey) throw new Error("Configura primero GPTPROTO_API_KEY");
const response = await fetch(
  "https://gptproto.com/api/v3/openai/gpt-image-2.6-flare/text-to-image",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${apiKey}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      prompt: "A square product photo of a navy bottle, soft side lighting, no text",
      n: 1,
      quality: "medium",
      size: "1024x1024",
      enable_sync_mode: false,
      response_format: "url",
    }),
    signal: AbortSignal.timeout(120000),
  },
);
if (!response.ok) throw new Error(`HTTP ${response.status}`);
const body = await response.json();
if (body.code !== 200 || !body.data) {
  throw new Error(body.message || "Prediction submission failed");
}
console.log(JSON.stringify(body.data, null, 2));

Esto imprime la predicción, no un archivo de imagen finalizado. Usa su valor urls.get para el sondeo autenticado y lee outputs solo después de que el estado cambie a completed, siguiendo el flujo de trabajo anterior.

Editar imágenes de referencia

La ruta Flare image-edit es independiente de la generación:

POST https://gptproto.com/api/v3/openai/gpt-image-2.6-flare/image-edit

Acepta JSON con los campos obligatorios images y prompt. GPT Proto describe images como una matriz de cadenas y permite hasta 16 imágenes de referencia. Enumera la misma calidad, tamaño, sincronización y configuración de entrega que la ruta de generación. Prepara las imágenes de referencia a través del flujo de carga compatible e inspecciona la solicitud generada. Usa esas cadenas de referencia en images; no sustituyas una ruta de archivo local, una codificación Base64 arbitraria o un campo multipart llamado image sin verificar la representación de entrada esperada. Por ejemplo, almacena las cadenas de referencia de ese flujo como una matriz JSON en GPTPROTO_REFERENCE_IMAGES y luego reutiliza el asistente de Python:

import json
import os
from flare_example import submit_and_poll
references = json.loads(os.environ["GPTPROTO_REFERENCE_IMAGES"])
if (
    not isinstance(references, list)
    or not 1 <= len(references) <= 16
    or not all(isinstance(item, str) and item for item in references)
):
    raise ValueError("Proporciona de 1 a 16 cadenas de referencia válidas del flujo de carga")
outputs = submit_and_poll(
    "image-edit",
    {
        "images": references,
        "prompt": "Replace only the tabletop with light oak. Preserve the bottle shape, printed label, camera angle, reflections, and shadow direction.",
        "n": 1,
        "quality": "medium",
        "size": "1024x1024",
        "enable_sync_mode": False,
        "response_format": "url",
    },
)
print(outputs)

Las máscaras y el marcado no son intercambiables

El esquema de edición actual de GPT Proto no incluye los campos mask o markup. No envíes una máscara en blanco y negro ni una capa de anotación transparente asumiendo que se interpretará como un límite de edición. OpenAI documenta la edición guiada por marcado en su guía de generación de imágenes, pero el soporte ascendente no es prueba de que la ruta JSON de GPT Proto exponga los mismos controles. Para esta ruta, comienza con entradas de referencia compatibles y una instrucción de edición precisa. Compara el resultado con el original, incluyendo las áreas que debían permanecer sin cambios.

Elige la calidad, el tamaño y la entrega por separado

Usa low para borradores económicos cuando cumplan con los requisitos, luego compara medium y configuraciones superiores para los recursos finales. Esta es una recomendación de flujo de trabajo, no una garantía medida de que una configuración más alta siempre produzca la mejor imagen o una latencia en particular.

El selector de tamaño publicado incluye opciones cuadradas, horizontales y verticales. Su guía de dimensiones requiere bordes divisibles por 16, un borde máximo de 3,840 píxeles, una relación de aspecto no más ancha o alta que 3:1 y un conteo total de píxeles entre 655,360 y 8,294,400. Comienza con los ajustes preestablecidos enumerados en lugar de asumir que cualquier ancho y alto personalizado será aceptado.

response_format controla la entrega: url o b64_json. No selecciona PNG, JPEG, WebP, GIF o SVG. El esquema de solicitud actual de GPT Proto no incluye output_format, frame_count, frame_duration_ms, complexity o negative_prompt.

OpenAI documenta capacidades adicionales, incluyendo salida SVG y GIF animado. Trátalas como capacidades ascendentes hasta que la ruta de GPT Proto que utilices las exponga explícitamente. No agregues campos no documentados a la solicitud ni describas estos formatos como salidas confirmadas de esta ruta.

Precios y costo por imagen aprobada

Tarifas verificadas el 8 de noviembre de 2026, hora del Pacífico. La referencia del modelo actual de GPT Proto enumera estas tarifas por token de imagen; los precios pueden cambiar.

La entrada de texto se factura por separado. Consulta la tarifa vigente y su precisión mostrada antes de estimar un trabajo completo. La página del modelo anuncia actualmente tarifas un 5% por debajo del precio de lista; esa es una declaración de precio específica del modelo, no un descuento garantizado en todos los modelos ni un ahorro fijo en cada imagen generada. Como ilustración, 1,000 tokens de salida de imagen facturables a $28.50 por millón cuestan $0.0285. Este es un ejemplo aritmético que cubre solo la salida, no un pronóstico de cuántos tokens utilizará una imagen en particular. La entrada de texto, el procesamiento de imágenes de referencia y las generaciones repetidas se suman al total.

La referencia de ruta actual no documenta un campo usage en su envoltorio de predicción. Utiliza la información de facturación disponible para tu cuenta; no bases tus informes de costos en un campo de respuesta no confirmado. Una mayor calidad, salidas más grandes y referencias adicionales pueden cambiar el consumo, pero aquí no se establece ningún multiplicador fijo ni precio de imagen por nivel.

Realiza un seguimiento del gasto total dividido por los activos aprobados para comparar flujos de trabajo. Un borrador más barato que necesita varias revisiones puede costar más que un resultado de mayor calidad a la primera. Comienza con n: 1, utiliza las dimensiones requeridas por la ubicación y aumenta el volumen solo después de verificar tanto la calidad de la salida como la facturación. Consulta los precios de GPT Proto para conocer los términos de pago actuales a nivel de cuenta.

Escribe prompts que puedas evaluar

Describe el activo, el sujeto, la composición, la iluminación, el estilo y las restricciones en lenguaje sencillo. Para una edición, separa el cambio solicitado de los detalles que deben permanecer sin cambios. No asumas que un orden de palabras fijo tiene una ventaja documentada en la ponderación de tokens.

Campaña de producto: “Crea un anuncio de estudio cuadrado para una botella aislante azul marino mate. Colócala en el tercio derecho sobre un pedestal gris pálido. Mantén la mitad izquierda despejada para el texto. Usa iluminación lateral suave y un fondo blanco cálido. Deja la imagen libre de texto.”

Revisión enfocada: “Cambia solo la superficie de la mesa a roble claro. Mantén el ángulo de la cámara, la forma de la botella, la etiqueta impresa, los reflejos y la dirección de la sombra sin cambios. Iguala la iluminación existente.”

Texto exacto: “Crea un póster de evento en formato vertical con el titular ‘NIGHT MARKET’ exactamente como está escrito. Usa un titular grande en la parte superior, una foto del producto en el centro y espacio libre en la parte inferior para añadir una fecha más tarde.”

Revisa las letras a tamaño completo e inspecciona el recorte final. Una salida visualmente convincente aún puede contener una etiqueta incorrecta o un área de texto inutilizable. La guía de prompts de GPT Image 2.5 proporciona ejercicios de prompts relacionados; sus ejemplos no son un punto de referencia para Flare 2.6.

Maneja errores sin crear trabajos duplicados

Verifica tanto la respuesta HTTP como el sobre de predicción. La aceptación de la solicitud, la finalización de la generación y la recuperación de activos son pasos independientes.

Utiliza una política de reintento limitada con jitter para las operaciones que se pueden reintentar. El retraso, el número de intentos y el plazo de la aplicación son tus opciones de configuración, no valores predeterminados garantizados de GPT Proto. No asumas que cada respuesta contiene un conjunto particular de encabezados de límite de tasa.

Registra los ID de predicción, el estado de la respuesta, el tiempo y los detalles de error saneados. No registres la clave API, las imágenes de referencia completas ni todo el cuerpo de la solicitud. Después de un tiempo de espera de red, recupera la predicción conocida siempre que sea posible antes de enviarla de nuevo; las generaciones duplicadas pueden generar cargos adicionales.

Mueve un flujo de trabajo existente a Flare 2.6

Una actualización es más que reemplazar una cadena de modelo. GPT Proto selecciona este modelo y tarea a través de la ruta. Mantén una integración existente disponible mientras pruebas la nueva generación o editas la ruta con prompts y referencias representativas.

Utiliza configuraciones explícitas de tamaño, calidad, cantidad de imágenes y entrega. Compara la precisión del texto, la preservación de los detalles del producto, el tiempo para obtener un resultado aprobado y el gasto total entre revisiones. Vuelve a verificar el análisis de respuesta y el comportamiento de sondeo antes de mover el tráfico de producción recurrente.

Si estás migrando desde un cliente de imágenes nativo de OpenAI, adapta el manejo de la carga útil y el resultado al sobre data.status y data.outputs de GPT Proto. No asumas que client.images.generate() o client.images.edit() pueden llamar a estas rutas nativas de GPT Proto sin cambios.