TL;DR
GPT-Image-2.5 é uma família de APIs de imagem com dois modelos: Flare prioriza geração rápida para o dia a dia, enquanto Sunburst prioriza precisão de edição e fidelidade do resultado final. Por meio da CometAPI, integrações existentes com o SDK da OpenAI normalmente migram apenas alterando a base URL, a chave de API e o ID do modelo. Comece com Flare em qualidade média, meça latência e o custo por imagem aprovada e direcione edições exigentes ou saídas premium para Sunburst.
Principais pontos
- Flare é a escolha voltada à velocidade para produtos interativos, iteração rápida e geração em alto volume.
- Sunburst é a escolha voltada à precisão para edições localizadas, preservação de referência e composições finais complexas.
- Ambos os modelos aceitam entradas de texto e imagem, oferecem seis modos de qualidade e geram ou editam imagens pela Images API.
- A CometAPI suporta os dois IDs de modelo por meio de uma base URL e padrão de SDK compatíveis com OpenAI.
- Resultados atuais do Arena favorecem Sunburst para geração e edição, enquanto ambos os modelos novos ainda estão marcados como preliminares.
- A seleção para produção deve considerar latência, taxa de aceitação, fidelidade de edição, uso de tokens e custo efetivo por imagem aprovada.
Em 8 de setembro de 2026, a OpenAI introduziu o ChatGPT Images 2.5 e lançou dois novos modelos de geração de imagens na API: GPT Image 2.5 Flare para geração de imagens rápida e cotidiana e GPT Image 2.5 Sunburst para fluxos de trabalho que priorizam qualidade de imagem e controle de edição mais rigoroso. A OpenAI posiciona Flare como o padrão para a maioria das aplicações, enquanto Sunburst é seu modelo mais capaz para geração e edição de imagens.
Ambos os modelos agora estão disponíveis por meio da CometAPI. A vantagem prática é que os desenvolvedores podem chamá-los pela interface familiar do SDK da OpenAI, substituindo a chave de API e a base URL pelas credenciais da CometAPI. A API compatível com OpenAI da CometAPI significa que um aplicativo de geração de imagens existente geralmente precisa apenas de uma pequena mudança na integração, em vez de um novo SDK ou arquitetura de requisição.
Este guia mostra como gerar e editar imagens com GPT-Image-2.5 via CometAPI usando cURL, Python e JavaScript, e como escolher o modelo certo, o nível de qualidade, as dimensões e o formato de saída para um fluxo de produção.
O que é a API GPT-Image-2.5?
GPT-Image-2.5 é a família atual de geração de imagens da OpenAI. Ela aceita entradas de texto e imagem e retorna imagens. A família possui dois modelos: GPT-Image-2.5 Flare, otimizado para velocidade e uso cotidiano, e GPT-Image-2.5 Sunburst, otimizado para capacidade máxima e edição precisa.
Como a API GPT-Image-2.5 se compara à API GPT Image 2?
A mudança principal não é apenas uma substituição única e mais rápida. GPT-Image-2.5 separa a carga de trabalho em duas opções com propósitos distintos. Flare mira geração rotineira com menor latência, enquanto Sunburst mira as tarefas de geração e edição mais exigentes. Ambos os modelos expõem a mesma superfície de controle ampla, incluindo níveis de qualidade de low a max, entradas de imagem para edição e streaming de imagens parciais.
Para migração, comece mantendo seus prompts e a estrutura de requisição atuais, depois selecione um modelo conforme os requisitos de latência e fidelidade. Re-teste renderização de texto, instruções de preservação, máscaras, ordem das imagens de referência, tamanho de saída e custo antes de alterar o tráfego de produção.
Por que usar GPT-Image-2.5 por meio da CometAPI?
A CometAPI fornece uma camada de acesso compatível com OpenAI que pode reduzir o trabalho de integração quando a equipe já usa esse gateway. Os benefícios práticos são gerenciamento centralizado de chaves, um formato de requisição familiar, visibilidade de uso e a capacidade de rotear geração e edição de imagens por uma única base URL.
| Item | Valor |
|---|---|
| Base URL | https://api.cometapi.com/v1 |
| Rota de geração | POST /images/generations |
| Rota de edição | POST /images/edits |
| Autenticação | Authorization: Bearer $COMETAPI_KEY |
Os preços do provedor e a disponibilidade do modelo podem mudar. Confirme o identificador do modelo, o comportamento do endpoint e a cobrança atual no painel da CometAPI antes do rollout em produção.
Como usar a API GPT-Image-2.5 na CometAPI
Passo 1: Obtenha uma chave de API da CometAPI
Crie ou acesse sua conta na CometAPI e gere um token no console de tokens da API CometAPI.
Armazene a chave como uma variável de ambiente em vez de fixá-la no código-fonte da aplicação:
| export COMETAPI_KEY="your-cometapi-key" |
|---|
No Windows PowerShell:
| $env:COMETAPI_KEY="your-cometapi-key" |
|---|
Não exponha a chave de API em JavaScript no lado do navegador, repositórios públicos, capturas de tela ou aplicativos cliente. Variáveis de ambiente no servidor ou um gerenciador de segredos são escolhas mais seguras para produção.
Passo 2: Gere sua primeira imagem com cURL
Para a maioria das aplicações, comece com Flare. Uma requisição mínima de geração se parece com isto:
curl "https://api.cometapi.com/v1/images/generations" \-H "Authorization: Bearer $COMETAPI_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "gpt-image-2.5-flare", "prompt": "Premium product photograph of a matte black wireless speaker on a light concrete pedestal, soft window light, realistic material texture, clean editorial composition, no text", "size": "1536x1024", "quality": "medium", "output_format": "png" }' |
|---|
As partes específicas da CometAPI mais importantes são o endpoint e a chave de API. A API do GPT Image 2.5 Flare na CometAPI usa o endpoint api.cometapi.com/v1/images/generations com autenticação Bearer.
Os modelos GPT Image normalmente retornam o conteúdo da imagem gerada por data[].b64_json em vez de exigir que seu aplicativo baixe uma URL permanente da imagem.
Uma resposta simplificada se parece com:
| { "data": [ { "b64_json": "<base64-image-data>" } ], "usage": { "input_tokens": 32, "output_tokens": 1372, "total_tokens": 1404 } } |
|---|
Seu aplicativo deve decodificar o campo Base64 e salvar os bytes retornados em vez de armazenar a string Base64 como o ativo final.
Passo 3: Gere uma imagem com Python
| import base64 import os import requests response = requests.post( "https://api.cometapi.com/v1/images/generations",
 headers={"Authorization": f"Bearer {os.environ['COMETAPI_KEY']}"}, json={ "model": "gpt-image-2.5-flare", "prompt": ( "A clean isometric illustration of a solar-powered research lab, " "white background, precise geometry, no labels or watermarks" ), "size": "1536x1024", "quality": "high", "output_format": "png", }, timeout=180, ) response.raise_for_status() payload = response.json() image_b64 = payload["data"][0]["b64_json"] with open("research-lab.png", "wb") as file: file.write(base64.b64decode(image_b64)) |
|---|
Esta é uma das maiores vantagens práticas da CometAPI para um projeto existente com o SDK da OpenAI: o exemplo oficial da CometAPI usa o mesmo cliente OpenAI, alterando base_url, a chave e o ID do modelo em vez de substituir a camada de SDK do aplicativo.
Passo 4: Use múltiplas imagens de referência com a Responses API
Atribua um papel estável a cada imagem antes de escrever o prompt. Uma ordem útil é: assunto primeiro, estilo em segundo, depois referência de fundo ou layout. Nomeie esses papéis explicitamente no prompt para que o modelo não precise inferir quais propriedades copiar.
import base64
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1",
)
response = client.responses.create(
model="gpt-6-astra",
input=[{
"role": "user",
"content": [
{"type": "input_text", "text": (
"Create a campaign image. Use image 1 only for the product "
"shape and colors; image 2 only for lighting and visual style; "
"image 3 only for the background composition. Preserve the "
"product logo exactly and add no other text."
)},
{"type": "input_image", "image_url": "https://example.com/product.png"},
{"type": "input_image", "image_url": "https://example.com/style.png"},
{"type": "input_image", "image_url": "https://example.com/background.png"},
],
}],
tools=[{
"type": "image_generation",
"model": "gpt-image-2.5-sunburst",
}],
)
for item in response.output:
if item.type == "image_generation_call":
with open("campaign.png", "wb") as file:
file.write(base64.b64decode(item.result))
A Responses API usa um modelo principal compatível no nível superior e seleciona o GPT-Image-2.5 dentro da ferramenta de geração de imagens. Se o gateway ainda não expuser o modelo principal selecionado ou o esquema da ferramenta, verifique o catálogo de modelos atual da CometAPI e use o equivalente documentado.
Observação: múltiplas imagens de referência podem ser enviadas de uma vez, com cada imagem desempenhando um papel distinto; especifique claramente a finalidade de cada imagem no prompt. Ao realizar edições com múltiplas imagens, atente para a ordem das entradas e a correspondência semântica.
Como editar imagens existentes
Use a rota de edição quando um ativo existente deve ser preservado e alterado. Declare o que deve permanecer fixo antes de descrever a mudança solicitada.
curl https://api.cometapi.com/v1/images/edits \
-H "Authorization: Bearer $COMETAPI_KEY" \
-F "model=gpt-image-2.5-sunburst" \
-F "image[]=@product.png" \
-F "prompt=Preserve the product shape, label, and camera angle. Replace only the background with a warm studio gradient. Add no new text." \
-F "quality=high" \
-F "output_format=png"
Entrada
Saída
Atribua papéis a múltiplas imagens de entrada
Não dependa apenas da ordem de upload. Diga “a imagem 1 é o assunto”, “a imagem 2 é a referência de estilo” e “a imagem 3 é a referência de fundo”. Em seguida, liste os atributos permitidos para transferência de cada imagem. Isso reduz a cópia acidental de rostos, logos, textos ou layouts da referência errada.
Use uma máscara para edições localizadas
Uma máscara orienta a área editável: pixels transparentes indicam onde a mudança é permitida, enquanto a área restante deve ser preservada. A máscara deve corresponder ao tamanho e formato da imagem de origem, incluir um canal alfa e permanecer dentro do limite de tamanho de arquivo da API. Com múltiplas imagens de entrada, a máscara se aplica à primeira imagem.
Uma máscara é uma orientação, não uma seleção pixel a pixel perfeita. Reforce-a com linguagem de preservação, como “altere apenas a região transparente; preserve todos os outros pixels, textos e geometria”.
Dicas de produção para GPT-Image-2.5 na CometAPI
A especificação do modelo não lista streaming genérico em nível de modelo como um recurso suportado, mas a Image API e a Responses API suportam streaming de geração de imagens com partial_images. Isso fornece prévias progressivas em vez de streaming de texto token a token: a Images API aceita valores de partial_images de 0 a 3 e pode retornar esse número de prévias durante a geração. Cada imagem parcial adiciona 100 tokens de saída. As equipes podem usar essas prévias para uma UI de progresso de geração; aplicações que não precisam de prévias podem continuar usando o fluxo padrão de geração e edição.
Mesmo que
partial_images: 3esteja definido, não há garantia de que exatamente três imagens parciais serão recebidas; se a imagem final for gerada rápido o suficiente, o número real recebido pode ser menor que o solicitado.
Parâmetros da API GPT-Image-2.5
GPT-Image-2.5 expõe mais controles de saída do que simplesmente escolher um prompt e um modelo.
| Parâmetro — guia de imagens da OpenAI | O que controla | Ponto de partida recomendado |
|---|---|---|
| quality | Nível de computação/detalhe | medium para desenvolvimento |
| size | Resolução/aspecto da imagem | 1024×1024 ou 1536×1024 |
| output_format | PNG, JPEG, WebP | PNG para fidelidade; WebP/JPEG para entrega |
| background | Saída opaca ou transparente | Use transparente apenas quando necessário |
| output_compression | Compressão para JPEG/WebP | Ajuste para entrega web |
| n | Número de imagens retornadas | Comece com 1 |
| prompt | Requisitos visuais | Torne explícitos o layout e as restrições |
Image API vs Responses API
| Critério | Image API | Responses API |
|---|---|---|
| Melhor para | Geração e edição diretas de uma vez | Workflows de imagem conversacionais, multi-etapas ou com agentes |
| Seleção de modelo | Define o modelo de imagem diretamente | Usa um modelo principal mais a ferramenta de geração de imagens |
| Múltiplas referências | Suportadas para edições, dependendo da rota | Encaixa naturalmente várias entradas por URL ou ID de arquivo |
| Iteração | O aplicativo reenvia o contexto | Projetada para turnos iterativos e chamadas de ferramentas |
| Prévias em streaming | Suporta imagens parciais | Suporta imagens parciais |
| Quando escolher | Você sabe o resultado desejado e quer a requisição mais curta | O modelo precisa raciocinar sobre contexto, referências ou resultados anteriores |
Regra prática: comece com a Image API. Migre para a Responses API quando o fluxo de trabalho precisar de estado de conversa, múltiplas referências semânticas ou outras ferramentas ao redor da geração de imagens.
Escolhendo a qualidade
A escala de qualidade suportada é:
| auto low medium high xhigh max |
|---|
auto deixa o modelo decidir. Porém, para desenvolvimento, escolher explicitamente medium torna os testes A/B mais controlados.
Um padrão útil de implantação é:
| low / medium → rascunhos, prévias, experimentação em alto volume high → ativos de produção aprovados xhigh / max → renders finais exigentes em que o ganho de qualidade compensa o custo |
|---|
Não use automaticamente max só porque está disponível. Mais tokens de saída de imagem aumentam o custo, e um prompt fraco não vira um bom prompt apenas elevando a qualidade.
Escolhendo o tamanho da imagem
Os presets comuns são:
| 1024x1024 1536x1024 1024x1536 |
|---|
Os modelos 2.5 também suportam dimensões arbitrárias válidas, o que é útil para banners, páginas de produto, criativos mobile e outros ativos não quadrados. A especificação atual da OpenAI permite dimensões de até 3840 pixels por lado dentro de seus limites de contagem de pixels e proporção de aspecto. Guia de prompts de imagem da OpenAI
Criando imagens transparentes
Use:
| { "background": "transparent", "output_format": "png" } |
|---|
ou WebP. Saída transparente requer um formato que suporte transparência alfa, então JPEG não é apropriado. Requisitos de fundo transparente
Isso é especialmente útil para recortes de produto, assets de UI, ícones, stickers e pipelines de composição.
Como criar prompts para GPT-Image-2.5
Um prompt confiável para produção separa o objetivo criativo das restrições. Escreva instruções positivas primeiro, depois preservação e restrições negativas.
Defina a composição
Especifique assunto, ângulo de câmera, enquadramento, profundidade, fundo e a posição relativa de objetos importantes. Exemplo: “Vista do produto em três quartos, centralizado, amplo espaço negativo à direita, câmera na altura dos olhos, visual de lente 50 mm”.
Descreva iluminação e materiais
Nomeie direção da luz, suavidade, contraste, temperatura de cor e resposta do material. Exemplo: “Softbox grande no canto superior esquerdo, leve luz de recorte, alumínio escovado realista, reflexos controlados”.
Controle texto exato
Coloque o texto obrigatório entre aspas e especifique posição, hierarquia, capitalização e tipografia. Peça para não adicionar texto adicional. Exemplo: “Coloque o título exato ‘BUILD WITH CLARITY’ no topo central em sans serif negrito e caixa alta. Preserve a ortografia exatamente. Não adicione outras palavras, letras, rótulos ou marcas d’água.”
Declare o que deve ser preservado
Para edição, nomeie os elementos que não podem mudar: identidade, pose, geometria do produto, logo, texto de rótulo, proporções, ângulo de câmera ou fundo. Coloque essas restrições antes da modificação solicitada.
Adicione restrições negativas
Liste modos de falha prováveis em linguagem direta: “Sem dedos extras, sem produtos duplicados, sem logo deformado, sem texto com erro ortográfico, sem borda, sem marca d’água.” Restrições negativas são mais úteis quando abordam riscos específicos, e não termos genéricos de qualidade.
Quanto custa o GPT-Image-2.5?
Custos oficiais da API da OpenAI
No momento da verificação, Flare e Sunburst listam os mesmos preços por token: US$ 5 por milhão de tokens de entrada de texto, US$ 1,25 por milhão de tokens de entrada de texto em cache, US$ 8 por milhão de tokens de entrada de imagem, US$ 2 por milhão de tokens de entrada de imagem em cache e US$ 30 por milhão de tokens de saída de imagem. O custo final depende dos tokens efetivamente usados, não apenas do número de requisições.
Preços da CometAPI e formas de reduzir custos
A CometAPI atualmente divulga um desconto de 20% para GPT-Image-2.5 Flare em seu catálogo de modelos. Trate o painel e a fatura como fonte da verdade, pois os preços do gateway podem mudar. Para reduzir gastos, use Flare para trabalho rotineiro, comece em medium ou high, reserve xhigh ou max para casos aprovados, reutilize entradas em cache quando suportado, evite variantes desnecessárias e defina partial_images como 0, a menos que prévias melhorem a experiência do usuário.
Outros fatores de custo e um exemplo prático
O custo é influenciado por comprimento do prompt, número e resolução de imagens de referência, dimensões de saída, qualidade, tokens de saída finais, variantes solicitadas, prévias parciais, novas tentativas e resultados rejeitados. Acompanhe tanto o gasto por requisição quanto o gasto por imagem aprovada.
Custo por imagem aprovada = gasto total de geração ÷ número de saídas que passam na revisão.
Exemplo ilustrativo: 10 tentativas a US$ 0,18 cada somam US$ 1,80. Se 6 imagens passam na revisão, o custo por imagem aprovada é US$ 0,30, não US$ 0,18. Se um prompt melhor reduz para 8 tentativas com 6 imagens aprovadas, o custo por imagem aprovada cai para US$ 0,24.
Flare vs. Sunburst: qual modelo usar?
A decisão deve ser orientada pela carga de trabalho, em vez de tratar Sunburst como substituto automático de Flare.
| Decisão | GPT Image 2.5 Flare | GPT Image 2.5 Sunburst |
|---|---|---|
| Aplicação interativa | Recomendado | Use seletivamente |
| Iteração rápida de prompt | Recomendado | Geralmente desnecessário |
| Geração criativa em alto volume | Recomendado | Depende da taxa de aceitação |
| Edição de produto/referência | Bom | Recomendado |
| Composição final complexa | Bom | Recomendado |
| Controle máximo de edição | Bom | Recomendado |
| UI sensível à latência | Recomendado | Menos indicado |
| Ativo final premium | Teste primeiro | Recomendado quando o ganho for mensurável |
Para muitos produtos, a arquitetura ótima não é “escolher um para sempre”. Direcione a maioria dos pedidos para Flare e envie revisões exigentes ou saídas finais de alto valor para Sunburst.
Como migrar de GPT Image 2 para GPT-Image-2.5?
Se você já usa o GPT Image 2 via CometAPI, a migração é relativamente pequena porque geração e edição continuam nas rotas da Images API.
A mudança mais simples é:
| # Antes model="gpt-image-2" # Depois: primeiro a velocidade model="gpt-image-2.5-flare" # Depois: primeiro a precisão model="gpt-image-2.5-sunburst" |
|---|
Mas não pare na troca do ID. Reavalie qualidade, dimensões de saída, latência, preservação do assunto, correção de texto, localidade da edição e uso real de tokens usando um conjunto de avaliação fixo.
A OpenAI recomenda especificamente manter constantes o prompt, as referências, as dimensões e o formato de saída ao comparar modelos, para que a mudança de modelo seja a variável medida. Orientação de migração da OpenAI
Dicas de produção para GPT-Image-2.5 na CometAPI
Para um serviço de produção, mantenha a implementação em torno do GPT-Image-2.5 deliberadamente pequena: armazene a chave de API no servidor, persista a imagem decodificada no seu próprio storage, faça log de modelo/qualidade/tamanho/latência/uso, limite novas tentativas e trate erros 400 de forma diferente de falhas transitórias 429 ou 5xx.
A CometAPI já publicou um guia dedicado cobrindo enfileiramento, concorrência limitada, backoff exponencial, IDs duráveis, storage, manifestos e rastreamento de custo em lote. Em vez de duplicar aquela implementação aqui, veja How to Automate Image Generation at Scale ao passar de uma chamada única de API para produção em lote.
Essa distinção é particularmente importante ao adaptar exemplos escritos para a API nativa da OpenAI diretamente para um endpoint de terceiros compatível com OpenAI.
Erros comuns da API GPT-Image-2.5
| Erro | Causa provável | O que fazer |
|---|---|---|
| 401 Unauthorized | Chave da CometAPI inválida/ausente | Verifique COMETAPI_KEY e o header Bearer |
| 400 Bad Request | Parâmetro, tamanho, formato ou ID inválido | Remova campos opcionais e teste uma requisição mínima |
| 429 Too Many Requests | Limite de concorrência ou de conta atingido | Faça backoff e tente novamente com jitter |
| 5xx repetidos | Problema temporário upstream/API | Tente novamente um número limitado de vezes |
| Imagem aparece como texto Base64 | b64_json não foi decodificado | Decodifique Base64 e salve os bytes |
| Falha em saída transparente | Formato de saída incompatível | Use PNG ou WebP |
| Edição altera demais | Prompt não restringe a preservação | Declare explicitamente o que deve permanecer igual |
| Custos sobem inesperadamente | Qualidade/resolução maiores ou novas tentativas | Faça log do uso por requisição e calcule custo por imagem aprovada |
Não tente novamente toda falha automaticamente. Uma requisição 400 malformada tende a permanecer malformada, enquanto repetir um erro de autenticação só gera mais tráfego com falha.
Limites de taxa e concorrência
| Nível | TPM | IPM |
|---|---|---|
| Tier 1 | 100K | 5 |
| Tier 2 | 250K | 20 |
| Tier 3 | 800K | 50 |
| Tier 4 | 3M | 150 |
| Tier 5 | 8M | 250 |
Conclusão
GPT-Image-2.5 oferece aos desenvolvedores uma divisão de modelos mais útil do que uma simples atualização geracional: Flare é otimizado para cargas de trabalho rápidas e cotidianas, enquanto Sunburst oferece uma opção de maior precisão para fluxos de geração e edição exigentes.
Por meio da CometAPI, ambos podem se encaixar em um aplicativo compatível com OpenAI existente com esforço mínimo de integração. Comece com o endpoint /v1/images/generations, Flare, uma configuração de qualidade controlada e um conjunto de prompts representativo. Adicione /v1/images/edits e Sunburst quando seu produto exigir preservação de referência mais forte ou mudanças visuais precisas.
A principal otimização não é simplesmente selecionar a configuração mais poderosa. Meça latência, uso de tokens, taxa de aceitação, precisão de edição e custo efetivo por imagem aprovada no trabalho que sua aplicação realmente atende. É isso que determina se Flare ou Sunburst é o melhor modelo para produção.
FAQ
O GPT-Image-2.5 está disponível na CometAPI?
Sim. Tanto GPT Image 2.5 Flare quanto GPT Image 2.5 Sunburst estão disponíveis por meio da CometAPI.
Preciso de uma chave de API separada da OpenAI?
Não. Ao chamar o modelo via CometAPI, a autenticação usa sua chave da CometAPI contra o endpoint da CometAPI.
Devo usar Flare ou Sunburst?
Comece com Flare para a maioria das cargas de geração. Use Sunburst quando a precisão de edição, composições complexas ou a preservação de detalhes de imagens de referência tiverem impacto mensurável na aceitação da saída. Isso segue o próprio posicionamento da OpenAI para os dois modelos.
O GPT-Image-2.5 pode editar imagens existentes?
Sim. As especificações atuais do modelo suportam entrada de imagens e edição de imagens, e a CometAPI expõe a capacidade de edição para a família. API do GPT Image 2.5 Flare na CometAPI
O GPT-Image-2.5 suporta imagens transparentes?
Sim. Defina background como transparente e use PNG ou WebP como formato de saída. Guia de prompts de imagem da OpenAI
Posso usar o SDK Python da OpenAI com a CometAPI?
Sim. Os exemplos atuais da CometAPI instanciam o cliente padrão da OpenAI com base_url="https://api.cometapi.com/v1" e uma chave da CometAPI. Exemplo de SDK da CometAPI