Preços da API de imagens da OpenAI: modelos GPT Image, qualidade e Python

O preço da API de imagens da OpenAI parece simples até a primeira fatura chegar. Não existe um preço fixo por imagem. Você paga por tokens, e a quantidade de tokens que uma imagem consome depende do modelo, do tamanho e da configuração de quality que você passa na sua chamada em Python. Uma imagem de 1024x1024 pode custar US$ 0,006 ou US$ 0,211 para exatamente o mesmo prompt, uma diferença de cerca de 35 vezes. Este artigo apresenta as tarifas atuais, os valores por imagem para cada nível de qualidade, uma configuração funcional em Python e os hábitos que evitam que um lote de 1.000 imagens vire uma surpresa.

💡 Leia isto primeiro: os valores em dólar abaixo vêm das tarifas de tokens publicadas pela OpenAI (US$ 30 por milhão de tokens de saída de imagem nos modelos atuais) e de calculadoras de terceiros que aplicam essas tarifas. A página de preços da OpenAI lista tokens e aponta para uma calculadora, não para uma tabela por imagem, então confira novamente antes de definir um orçamento.

O que a API de imagens cobra

Tokens, não tarifas fixas

Cada requisição à API de Images é cobrada em três contadores. Tokens de entrada de texto são o seu prompt. Tokens de entrada de imagem aparecem apenas quando você envia fotos de referência para uma edição. Tokens de saída de imagem são a imagem que você recebe de volta, e quase sempre são a maior linha da conta.

Com as tarifas atuais, a fórmula é simples: tokens de texto vezes US$ 5, tokens de entrada de imagem vezes US$ 8, tokens de saída de imagem vezes US$ 30, tudo por milhão. O tamanho do prompt quase não pesa. Um prompt de 200 tokens custa US$ 0,001, enquanto uma única saída em alta qualidade pode passar de 1.700 tokens, o que dá cerca de US$ 0,05 só pela imagem.

Tarifas atuais de cada modelo GPT Image

Estas são as tarifas de tokens da OpenAI por 1 milhão de tokens para cada modelo da família:

A entrada em cache é mais barata: US$ 1,25 por milhão para texto e US$ 2,00 para imagens na família GPT Image 2. As duas variantes 2.5 compartilham exatamente as tarifas do GPT Image 2, então a lista de preços não diz qual escolher. O consumo de tokens diz.

Níveis de qualidade e seus custos

As cinco configurações de qualidade

Os modelos 2.5 aceitam low, medium, high, xhigh, max e auto para o parâmetro quality. O GPT Image 2 funciona com três níveis: low, medium e high. Para os modelos 2.5, uma análise da Kanaries lista os tokens de saída por nível, e multiplicando por US$ 30 por milhão, obtêm-se estes preços por imagem:

Dois detalhes se destacam. Primeiro, os retângulos são mais baratos que os quadrados em todos os níveis, cerca de 20 a 22 por cento, então escolha paisagem ou retrato sempre que o layout permitir. Segundo, a curva de preço é íngreme: max custa cerca de 36 vezes low.

GPT Image 2 tem seus preços citados por calculadoras como a CostGoat em US$ 0,006, US$ 0,053 e US$ 0,211 para low, medium e high em 1024x1024, e US$ 0,005, US$ 0,041 e US$ 0,165 para os retângulos. Esses valores em dólar batem com as linhas 2.5 low, high e max, o que sugere que os modelos 2.5 acrescentam faixas mais finas no meio. Confirme a contagem de tokens na sua própria conta antes de confiar nesse mapeamento.

Custo de 1.000 imagens

Os centavos por imagem escondem o orçamento real. Multiplicando as contagens de tokens por um lote de 1.000 imagens, temos:

Some cerca de US$ 0,75 por 1.000 imagens para um prompt de 150 tokens. Essa é a conta inteira do prompt. A configuração de qualidade é a verdadeira alavanca do orçamento.

Quando low já basta

Low custa cerca de um nono de high, e muito trabalho não precisa de mais. Miniaturas, moodboards, testes de conceito e testes A/B de composição ficam bons em low. Imagens de destaque, mockups de embalagem e tudo o que o cliente vai ampliar merecem high ou acima.

Comece com medium. Ele custa cerca de 2,2 vezes low e um quarto de high, e é um padrão sensato para um pipeline que ninguém mediu ainda.

Qual modelo serve para a sua carga de trabalho

A variante rápida

O GPT Image 2.5 Flare é posicionado para geração rápida no dia a dia. Uma análise aponta uma latência cerca de metade da do GPT Image 2. Essa velocidade importa mais no Python do que em uma janela de chat: quando um usuário espera por uma requisição web, cada segundo conta, e chamadas mais rápidas também significam menos conexões abertas para gerenciar.

A variante precisa

O GPT Image 2.5 Sunburst é voltado para fluxos de trabalho em que a precisão da edição importa mais, como preservar detalhes finos ao mudar um único elemento. Ele é mais lento e cobra as mesmas tarifas por token do Flare. Se o seu pipeline edita sobretudo fotos de produtos, teste o Sunburst primeiro. Se ele cria sobretudo imagens novas, comece pelo Flare.

Modelos mais antigos que ainda valem a pena

O GPT Image 1 Mini chega no máximo a US$ 0,052, cerca de um quarto dos US$ 0,211 do modelo principal, o que faz dele a opção econômica para trabalho em massa que tolera menos fidelidade. O GPT Image 1 é o que merece atenção: a CostGoat lista um desligamento em 23 de outubro de 2026, então confirme a data na página de descontinuações da OpenAI e evite começar qualquer coisa nova nele.

Configuração do Python passo a passo

Sua primeira requisição

Instale o SDK com pip install openai e defina suas credenciais no ambiente. O cliente as lê automaticamente, então nada sensível fica no seu código.

import base64
from pathlib import Path
from openai import OpenAI

client = OpenAI(timeout=180)

result = client.images.generate(
    model="gpt-image-2.5-flare",
    prompt="Studio photo of a cobalt-blue ceramic mug on a pale gray backdrop, soft light from the left",
    size="1536x1024",
    quality="medium",
)

Path("mug.png").write_bytes(base64.b64decode(result.data[0].b64_json))

Copiar prompt

A imagem chega em base64 em b64_json, então decodifique e grave os bytes. A OpenAI observa que prompts complexos podem levar até dois minutos, por isso o cliente acima define um timeout explícito de 180 segundos. Uma requisição travada falha então após três minutos, em vez de deixar um worker parado.

Registrando o custo real

Não confie em uma tabela, incluindo as acima. Registre o que cada chamada realmente usou e converta para dólares:

TEXT_IN = 5.00 / 1_000_000
IMAGE_IN = 8.00 / 1_000_000
IMAGE_OUT = 30.00 / 1_000_000

def cost_of(result):
    usage = result.usage
    details = usage.input_tokens_details
    return (
        details.text_tokens * TEXT_IN
        + details.image_tokens * IMAGE_IN
        + usage.output_tokens * IMAGE_OUT
    )

print(f"${cost_of(result):.4f}")

Copiar prompt

💡 Dica: estes nomes de campos seguem o objeto de uso da API de Images. Imprima result.usage uma vez na sua versão do SDK para confirmá-los antes de montar relatórios em cima.

Rascunho em low, acabamento em high

Um ciclo de rascunhos baratos se paga em poucas imagens. Renderize quatro rascunhos em low, escolha a redação do prompt que funciona e depois gaste uma vez com uma renderização em high:

PROMPT = "Studio photo of a cobalt-blue ceramic mug on a pale gray backdrop, soft light from the left"
MODEL = "gpt-image-2.5-flare"

drafts = [
    client.images.generate(model=MODEL, prompt=PROMPT, size="1536x1024", quality="low")
    for _ in range(4)
]
# Review the drafts, adjust PROMPT, then pay for one final render.
final = client.images.generate(model=MODEL, prompt=PROMPT, size="1536x1024", quality="high")

Copiar prompt

A conta em 1536x1024: quatro rascunhos a US$ 0,0047 mais uma versão final a US$ 0,0412 somam cerca de US$ 0,060. Três tentativas às cegas com high custam cerca de US$ 0,123. Uma ressalva: a renderização final não vai ser idêntica ao rascunho pixel por pixel, então o ciclo de rascunhos serve para escolher o prompt, não a imagem.

Custos que surpreendem as equipes

Edições custam mais

Imagens de referência são cobradas como entrada de imagem a US$ 8 por milhão de tokens. Em um cálculo modelado por Omid Saffari, uma geração nova com 200 tokens de texto e 2.000 tokens de saída custa US$ 0,061. Adicione uma imagem de referência de 6.000 tokens e a mesma requisição passa a custar US$ 0,109. O cache da entrada repetida reduz para cerca de US$ 0,072. São ilustrações com premissas declaradas, não contas típicas, mas mostram a direção: fluxos de edição custam mais do que a geração.

Retentativas e taxa de aprovação

O número que importa é o custo por imagem aprovada: o custo de uma tentativa dividido pela fração de tentativas que você aproveita.

• High a US$ 0,0527 com 60% aprovadas: cerca de US$ 0,088 por imagem aproveitada.
• Medium a US$ 0,0132 com 40% aprovadas: cerca de US$ 0,033 por imagem aproveitada.
• Low a US$ 0,0059 com 15% aprovadas: cerca de US$ 0,039 por imagem aproveitada.

Um nível mais barato ainda pode vencer mesmo quando você rejeita mais da saída dele. Meça a sua própria taxa de aprovação durante uma semana antes de escolher um padrão.

Limites de taxa por nível

A vazão é limitada pelo seu nível de uso. Estes são os limites que a OpenAI lista para o GPT Image 2:

No Tier 1, cinco imagens por minuto significam no máximo 300 por hora. No Tier 3, 1.000 imagens são concluídas em 20 minutos. Envolva seu loop em um pequeno semáforo ou em uma retentativa com backoff, para que uma rajada de erros 429 não vire uma rajada de retentativas desperdiçadas.

Formas de reduzir a conta

• Use a Batch API quando puder esperar. Relata-se que o GPT Image 2 roda em Batch pela metade das tarifas padrão de token para trabalhos que toleram até 24 horas. Os mesmos relatos dizem que nenhuma das variantes 2.5 oferece suporte a isso.
• Escolha paisagem ou retrato. Cerca de 20 por cento mais barato que o quadrado em todos os níveis.
• Rascunhe em low, finalize uma vez. O ciclo acima custa cerca de metade de três tentativas às cegas em high.
• Limite as tentativas. Coloque um limite rígido de retentativas por prompt e registre cada falha.
• Envie uma referência, não cinco. Os tokens de entrada de imagem se acumulam em cada edição.
• Redija os prompts com um modelo de linguagem. O GPT 5.6 Luna é um modelo rápido para escrever variações de prompt, e o GPT 5 Structured devolve um JSON limpo que o seu script em Python pode converter em prompt, tamanho e qualidade por linha. Mantenha uma única chamada de modelo de linguagem por lote de prompts, já que essa chamada tem taxa própria.

Revise os rascunhos lado a lado antes de qualquer passagem de high. Uma folha de contato com 12 rascunhos de baixo custo permite que um designer circule os dois que valem a pena finalizar, e essa revisão leva minutos.

Como usar o Flare no PicassoIA

Antes de colocar uma chamada de API em um script, você pode testar o mesmo modelo no navegador. O GPT Image 2.5 Flare está no PicassoIA, e seus parâmetros espelham os da API, o que o torna um bom ambiente de testes para decidir qual nível chamar a partir do Python.

1. Abra a página do modelo. Acesse o GPT Image 2.5 Flare no PicassoIA.
2. Escreva o prompt. É o único campo obrigatório. Descreva assunto, luz e enquadramento em uma ou duas frases, como no exemplo em Python.
3. Escolha quality. O padrão é auto. Use uma configuração baixa para rascunhos e uma alta quando a composição estiver final. A página informa que qualidade maior leva mais tempo e custa mais.
4. Defina aspect_ratio. O padrão é 1:1. Teste uma proporção de paisagem, já que é o formato mais barato na API.
5. Ajuste os extras. number_of_images aceita de 1 a 10 para você comparar opções a partir de um único prompt. output_format vem como webp por padrão, output_compression como 90, e background pode ser definido como transparente para recortes. input_images aceita fotos de referência para edições.
6. Gere e baixe. Salve o melhor resultado e anote quais configurações o produziram.

💡 Dica: rode um prompt em low e em high no GPT Image 2.5 Flare, depois compare a saída com o GPT Image 2 e o GPT Image 1 Mini antes de levar qualquer um deles para um pipeline.

O PicassoIA também oferece uma API para desenvolvedores no estilo Replicate em api.picassoia.com/v1, com autenticação por Bearer token, previsões assíncronas de criar e depois consultar, e um limite de cinco previsões simultâneas por conta. Ela atende o PicassoIA Image e o PicassoIA Image Editor Pro, entre outros. Consulte picassoia.com/en/api para as condições de acesso e os preços atuais, já que este artigo não os informa.

Faça seu próprio teste de preço

Tabelas de preço só vão até certo ponto. O melhor número é aquele que você mede com os seus próprios prompts, a sua própria taxa de aprovação e os seus próprios tamanhos. Escolha três prompts da sua carga de trabalho real, renderize cada um em low, medium e high, e registre o custo com a função auxiliar acima. Depois decida qual nível merece seu lugar.

Se você quer ver a diferença de qualidade antes de gastar um centavo na API, abra o GPT Image 2.5 Flare ou o GPT Image 2.5 Sunburst no PicassoIA e gere o seu próprio conjunto. Teste uma foto de produto, um retrato e um pôster com texto curto, depois compare-os em diferentes configurações. Sua primeira imagem de teste está a um clique.