API do GPT Image 2.6 Flare: Geração, Edição e Precificação

Para que serve o Flare

O Flare foi posicionado para rascunhos rápidos, visualizações frequentes e revisões interativas. Usos práticos incluem explorar fundos para fotos de produtos, testar composições de campanhas e gerar várias direções visuais antes de escolher uma para finalizar. GPT Image 2.6 Sunburst é a alternativa focada em detalhes e consistência na mesma família. Não é simplesmente um “modo de ilustração”, e o Flare não se limita ao fotorrealismo. Compare-os com base nos detalhes que determinam a aprovação: fidelidade da etiqueta, layout, preservação de um objeto aprovado e o número de revisões necessárias. Use o catálogo de modelos para verificar a disponibilidade atual. Uma conta compartilhada não torna as entradas, rotas de tarefas ou configurações de saída de todos os modelos idênticas.

Configure sua chave de API

Crie uma chave no painel de chaves de API do GPT Proto, depois disponibilize-a para o seu aplicativo no lado do servidor:

export GPTPROTO_API_KEY="sua_chave_de_api_aqui"

Mantenha a chave fora do código do navegador e do controle de versão. Carregue-a a partir de uma variável de ambiente ou do armazenamento de segredos da sua implantação. Se você usar um arquivo local .env, exclua esse arquivo dos commits. Para este guia, a origem da API é https://gptproto.com. Os caminhos de geração e edição abaixo já contêm /api/v3; não adicione /v1 no início nem substitua por uma URL base de chat-completions. Uma solicitação de lista de modelos bem-sucedida não é prova de que uma rota de imagem pode concluir um trabalho. Verifique o fluxo completo de envio e resultado com uma pequena solicitação antes de adicionar o processamento em lote.

Gerar uma imagem

A rota de texto para imagem do Flare publica este endpoint:

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

Comece com uma imagem e configurações explícitas para que a solicitação seja fácil de inspecionar:

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": "Uma foto de estúdio quadrada de uma garrafa térmica azul-marinho fosca sobre um pedestal cinza claro. Iluminação lateral suave, fundo branco quente, espaço para texto à esquerda. Sem texto.",
    "n": 1,
    "quality": "medium",
    "size": "1024x1024",
    "enable_sync_mode": false,
    "response_format": "url"
  }'

O modelo é selecionado pela URL. Esta rota publicada não requer um campo model separado, e size é opcional em vez de um terceiro campo obrigatório.

Campos de Solicitação

Recuperar o Resultado

O envio e a recuperação de resultados usam um envelope contendo code, message e data. O sucesso HTTP por si só não significa que a geração foi concluída. Verifique o code de nível de negócio, bem como o status da previsão.

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

Use a mesma autenticação Bearer ao fazer o polling. Para response_format: "url", as saídas concluídas são URLs de arquivo. Para b64_json, o array de saída documentado pode conter strings Base64. Nenhum dos casos utiliza a suposição nativa da OpenAI data[0].b64_json para esta rota do GPT Proto. Salve os ativos que você precisa reter, preserve seu tipo de mídia real e não dependa de um tempo de vida de URL hospedada não documentado.

Python: Enviar e consultar

Instale o requests no ambiente do seu aplicativo. O exemplo a seguir envia uma solicitação, consulta a URL de resultado retornada e imprime as URLs de saída concluídas. O prazo de cinco minutos é um tempo limite do aplicativo usado neste exemplo, não uma garantia de serviço.

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)

Salve o script como flare_example.py se você quiser reutilizar seu auxiliar no exemplo de edição abaixo. Ele para intencionalmente em erros de solicitação em vez de reenviar automaticamente uma geração potencialmente cobrável. Adicione o tratamento de novas tentativas em produção em torno da operação apropriada após verificar se a previsão original existe.

Node.js: Enviar uma Geração

Com um runtime Node.js atual que suporte fetch e AbortSignal.timeout, você pode enviar o mesmo JSON sem um wrapper de imagem específico do SDK. Salve este exemplo como um arquivo .mjs :

const apiKey = process.env.GPTPROTO_API_KEY;
if (!apiKey) throw new Error("Defina GPTPROTO_API_KEY primeiro");
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));

Isso imprime a previsão, não um arquivo de imagem finalizado. Use seu valor urls.get para polling autenticado e leia outputs apenas após o status se tornar completed, seguindo o fluxo de trabalho acima.

Editar imagens de referência

A rota Flare image-edit é separada da geração:

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

Ela aceita JSON com os campos obrigatórios images e prompt. O GPT Proto descreve images como uma matriz de strings e permite até 16 imagens de referência. Ela lista as mesmas configurações de qualidade, tamanho, sincronização e entrega da rota de geração. Prepare as imagens de referência através do fluxo de upload suportado e inspecione a requisição gerada. Use essas strings de referência em images; não substitua por um caminho de arquivo local, uma codificação Base64 arbitrária ou um campo multipart chamado image sem verificar a representação de entrada esperada. Por exemplo, armazene as strings de referência desse fluxo como uma matriz JSON em GPTPROTO_REFERENCE_IMAGES, então reutilize o auxiliar 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("Forneça de 1 a 16 strings de referência válidas do fluxo de upload")
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)

Máscaras e marcações não são intercambiáveis

O esquema de edição atual do GPT Proto não lista os campos mask ou markup. Não envie uma máscara em preto e branco ou uma camada de anotação transparente assumindo que ela será interpretada como um limite de edição. A OpenAI documenta a edição guiada por marcação em seu guia de geração de imagens, mas o suporte upstream não é prova de que a rota JSON do GPT Proto exponha os mesmos controles. Para esta rota, comece com entradas de referência suportadas e uma instrução de edição precisa. Compare o resultado com o original, incluindo áreas que deveriam permanecer inalteradas.

Escolha a qualidade, o tamanho e a entrega separadamente

Use low para rascunhos de baixo custo quando atenderem ao briefing, e então compare as configurações medium e superiores para os ativos finais. Esta é uma recomendação de fluxo de trabalho, não uma garantia medida de que uma configuração mais alta sempre produzirá a melhor imagem ou uma latência específica.

O seletor de tamanho publicado inclui opções quadradas, paisagem e retrato. Sua orientação de dimensões requer bordas divisíveis por 16, uma borda máxima de 3.840 pixels, uma proporção de aspecto não maior ou mais alta que 3:1 e uma contagem total de pixels entre 655.360 e 8.294.400. Comece com as predefinições listadas em vez de presumir que qualquer largura e altura personalizada serão aceitas.

response_format controla a entrega: url ou b64_json. Ele não seleciona PNG, JPEG, WebP, GIF ou SVG. O esquema de solicitação atual do GPT Proto não lista output_format, frame_count, frame_duration_ms, complexity ou negative_prompt.

A OpenAI documenta recursos adicionais, incluindo saída SVG e GIF animado. Trate-os como recursos upstream até que a rota do GPT Proto que você usa os exponha explicitamente. Não adicione campos não documentados à solicitação nem descreva esses formatos como saídas confirmadas desta rota.

Preços e custo por imagem aprovada

Taxas verificadas em 8 de novembro de 2026, horário do Pacífico. A referência de modelo atual do GPT Proto lista estas taxas por token de imagem; os preços podem sofrer alterações.

A entrada de texto é cobrada separadamente. Verifique a taxa em tempo real e sua precisão exibida antes de estimar um trabalho completo. A página do modelo anuncia atualmente taxas 5% abaixo do preço de lista; essa é uma declaração de preço específica do modelo, não um desconto garantido em todos os modelos ou uma economia fixa em cada imagem gerada. Para fins de ilustração, 1.000 tokens de saída de imagem faturáveis a US$ 28,50 por milhão custam US$ 0,0285. Este é um exemplo aritmético que cobre apenas a saída — não uma previsão de quantos tokens uma imagem específica consumirá. A entrada de texto, o processamento de imagem de referência e gerações repetidas aumentam o total.

A referência de rota atual não documenta um campo usage em seu envelope de previsão. Use as informações de cobrança disponíveis para sua conta; não crie relatórios de custos baseados em um campo de resposta não confirmado. Saídas de maior qualidade, maiores e referências adicionais podem alterar o consumo, mas nenhum multiplicador fixo ou preço de imagem por nível é estabelecido aqui.

Acompanhe o gasto total dividido pelos ativos aprovados para comparar fluxos de trabalho. Um rascunho mais barato que precisa de várias revisões pode custar mais do que um resultado de primeira qualidade superior. Comece com n: 1, use as dimensões exigidas pelo posicionamento e aumente o volume apenas após verificar a qualidade da saída e a cobrança. Consulte preços do GPT Proto para ver os termos de pagamento atuais da conta.

Escreva prompts que você possa avaliar

Descreva o ativo, o assunto, a composição, a iluminação, o estilo e as restrições em linguagem simples. Para uma edição, separe a alteração solicitada dos detalhes que devem permanecer inalterados. Não presuma que uma ordem fixa de palavras tenha uma vantagem documentada de ponderação de tokens.

Campanha de produto: “Crie um anúncio de estúdio quadrado para uma garrafa térmica azul-marinho fosca. Coloque-a no terço direito sobre um pedestal cinza-claro. Mantenha a metade esquerda livre para o texto. Use iluminação lateral suave e um fundo branco quente. Deixe a imagem sem texto.”

Revisão focada: “Altere apenas o tampo da mesa para carvalho claro. Mantenha o ângulo da câmera, o formato da garrafa, o rótulo impresso, os reflexos e a direção da sombra inalterados. Combine com a iluminação existente.”

Texto exato: “Crie um pôster de evento vertical com a manchete ‘NIGHT MARKET’ exatamente como escrito. Use uma manchete grande no topo, uma foto do produto no centro e espaço livre na parte inferior para uma data a ser adicionada posteriormente.”

Revise as letras em tamanho real e inspecione o corte final. Uma saída visualmente convincente ainda pode conter um rótulo incorreto ou uma área de cópia inutilizável. O guia de prompt do GPT Image 2.5 fornece exercícios de prompt relacionados; seus exemplos não são um parâmetro para o Flare 2.6.

Trate erros sem criar tarefas duplicadas

Verifique tanto a resposta HTTP quanto o envelope de previsão. A aceitação da solicitação, a conclusão da geração e a recuperação de ativos são etapas separadas.

Use uma política de nova tentativa limitada com jitter para operações que podem ser repetidas. O atraso, a contagem de tentativas e o prazo do aplicativo são suas escolhas de configuração — não padrões garantidos do GPT Proto. Não presuma que toda resposta contém um conjunto específico de cabeçalhos de limite de taxa.

Registre IDs de previsão, status da resposta, tempo e detalhes de erro higienizados. Não registre a chave de API, imagens de referência completas ou todo o payload da solicitação. Após um tempo limite de rede, recupere a previsão conhecida sempre que possível antes de enviar novamente; gerações duplicadas podem incorrer em cobranças adicionais.

Migre um fluxo de trabalho existente para o Flare 2.6

Uma atualização é mais do que substituir uma string de modelo. O GPT Proto seleciona este modelo e tarefa através do caminho da rota. Mantenha uma integração existente disponível enquanto você testa a nova geração ou edita a rota com prompts e referências representativos.

Use configurações explícitas de tamanho, qualidade, contagem de imagens e entrega. Compare a precisão do texto, a preservação dos detalhes do produto, o tempo para um resultado aprovado e o gasto total entre as revisões. Verifique novamente a análise de resposta e o comportamento de polling antes de mover o tráfego de produção recorrente.

Se você estiver migrando de um cliente de imagem nativo da OpenAI, adapte o tratamento de payload e resultado para o envelope data.status e data.outputs do GPT Proto. Não presuma que client.images.generate() ou client.images.edit() podem chamar essas rotas nativas do GPT Proto sem alterações.