Monitorização de custos e utilização
Nesta página
Monitorização de custos e utilização
Os custos da API podem sair rapidamente do controlo se não os vigiar. Esta lição ensina-o a acompanhar, estimar e controlar as suas despesas em produção. A história repete-se de projeto para projeto: uma funcionalidade entra em linha numa quinta-feira, ninguém verifica o painel de controlo durante o fim de semana e, na segunda-feira de manhã, a fatura equivale ao orçamento mensal inteiro. Os passos abaixo ajudam-no a detetar o desvio de custos no momento em que ocorre, e não trinta dias depois.
Compreender a faturação
Os custos são calculados por milhão de tokens, com preços diferentes para entrada (input) e saída (output). Esta assimetria tem consequências diretas nas suas escolhas de design: enviar um documento longo como entrada custa significativamente menos do que pedir ao modelo que gere um documento longo. Cada resposta devolve a contagem exata para ambas as direções, pelo que nunca precisa de estimar.
from openai import OpenAI
client = OpenAI()
# Every response includes usage metrics
response = client.responses.create(
model="gpt-5.6-terra",
input="Explain OpenAI API billing."
)
usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Output tokens: {usage.output_tokens}")
print(f"Total tokens: {usage.total_tokens}")
# Output costs more than input!
Calculadora de custos
Converter estes contadores em dólares requer uma grelha de preços. Isole-a numa estrutura dedicada em vez de espalhar constantes por todo o seu código: quando os preços mudarem ou adicionar um modelo, só precisará de modificar uma linha. As tarifas abaixo são indicativas e devem ser verificadas durante cada revisão orçamental.
from dataclasses import dataclass
@dataclass
class ModelRate:
input_per_million: float
output_per_million: float
# Approximate prices in USD per million tokens
# Always check current prices on platform.openai.com/pricing
RATES = {
"gpt-5.6-luna": ModelRate(input_per_million=0.20, output_per_million=1.20),
"gpt-5.6-terra": ModelRate(input_per_million=2.0, output_per_million=12.0),
"gpt-5.6-sol": ModelRate(input_per_million=5.0, output_per_million=30.0),
}
def calculate_cost(model: str, input_tokens: int,
output_tokens: int) -> float:
"""Calculates the cost of a call in USD."""
rate = RATES.get(model)
if not rate:
raise ValueError(f"Unknown model: {model}")
input_cost = (input_tokens / 1_000_000) * rate.input_per_million
output_cost = (output_tokens / 1_000_000) * rate.output_per_million
return input_cost + output_cost
# Example
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Cost: ${cost:.6f}")
# Result: Cost: $0.008000
Oito décimos de cêntimo por chamada parece tranquilizador até multiplicar esse valor pelas cinquenta mil chamadas diárias de um chatbot em produção — isso são quatrocentos dólares por dia. Adote sempre o hábito de pensar em volumes mensais, nunca por chamada.
Monitor de custos em tempo real
Os cálculos unitários são inúteis se não forem agregados. Este monitor agrega as despesas em três eixos — por dia, por modelo e por número de chamadas — e compara o total do dia com um orçamento que definiu. Os alertas são graduais: um aviso quando restam menos de 20% do orçamento, seguido de um alerta rígido ao ultrapassar o limite. Este passo intermédio é valioso porque lhe dá tempo para intervir antes que o serviço seja cortado.
import json
from datetime import datetime, date
from collections import defaultdict
class CostTracker:
"""Real-time API cost tracking."""
def __init__(self, daily_budget_usd: float = 10.0):
self.daily_budget = daily_budget_usd
self.costs_per_day: dict[str, float] = defaultdict(float)
self.costs_per_model: dict[str, float] = defaultdict(float)
self.calls_per_day: dict[str, int] = defaultdict(int)
self.total_tokens = 0
def record(self, model: str, input_tokens: int,
output_tokens: int):
"""Records the costs of a call."""
cost = calculate_cost(model, input_tokens, output_tokens)
today = date.today().isoformat()
self.costs_per_day[today] += cost
self.costs_per_model[model] += cost
self.calls_per_day[today] += 1
self.total_tokens += input_tokens + output_tokens
return cost
def remaining_budget(self) -> float:
"""Returns the remaining budget for today."""
today = date.today().isoformat()
return self.daily_budget - self.costs_per_day[today]
def budget_alert(self) -> bool:
"""Checks if the budget is close to the limit."""
remaining = self.remaining_budget()
if remaining <= 0:
print("ALERT: Daily budget exceeded!")
return True
elif remaining < self.daily_budget * 0.2:
print(f"WARNING: ${remaining:.2f} remaining on daily budget")
return True
return False
def report(self) -> dict:
"""Generates a cost report."""
return {
"total_cost_usd": sum(self.costs_per_day.values()),
"cost_today_usd": self.costs_per_day.get(
date.today().isoformat(), 0
),
"remaining_budget_usd": self.remaining_budget(),
"costs_per_model": dict(self.costs_per_model),
"total_tokens": self.total_tokens,
}
# Usage
tracker = CostTracker(daily_budget_usd=5.0)
response = client.responses.create(
model="gpt-5.6-terra",
input="Hello!"
)
cost = tracker.record(
model="gpt-5.6-terra",
input_tokens=response.usage.input_tokens,
output_tokens=response.usage.output_tokens
)
print(f"Cost of this call: ${cost:.6f}")
print(json.dumps(tracker.report(), indent=2))
Cliente com controlo de orçamento
A monitorização nem sempre é suficiente: perante um ciclo defeituoso que chama a API continuamente, precisa de um disjuntor financeiro. Este cliente verifica o orçamento restante antes de emitir o pedido e recusa liminarmente a chamada se o envelope estiver esgotado. O serviço degrada-se, mas de forma controlada, sem faturas surpresa. A contabilidade de custos ocorre depois, assim que a utilização real é conhecida.
class BudgetControlledClient:
"""Client that refuses calls if the budget is exceeded."""
def __init__(self, daily_budget: float = 10.0):
self.client = OpenAI()
self.tracker = CostTracker(daily_budget_usd=daily_budget)
def create(self, model: str, input: str, **kwargs) -> object:
"""API call with budget control."""
# Check budget before the call
if self.tracker.remaining_budget() <= 0:
raise RuntimeError(
"Daily budget exhausted. "
f"Spent: ${self.tracker.report()['cost_today_usd']:.2f}"
)
response = self.client.responses.create(
model=model,
input=input,
**kwargs
)
cost = self.tracker.record(
model=model,
input_tokens=response.usage.input_tokens,
output_tokens=response.usage.output_tokens
)
# Alert if budget is low
self.tracker.budget_alert()
return response
# Usage
budget_client = BudgetControlledClient(daily_budget=2.0)
try:
response = budget_client.create("gpt-5.6-terra", "Hello!")
print(response.output_text)
except RuntimeError as e:
print(f"Blocked: {e}")
Otimização de custos
1. Escolher o modelo certo
A alavanca mais poderosa continua a ser o encaminhamento por complexidade. Uma tarefa de classificação em três categorias não precisa do modelo mais caro: para esta tarefa, a diferença na fatura atinge um fator de vinte e cinco para uma qualidade idêntica. Torne a complexidade um parâmetro explícito da sua função, em vez de uma decisão codificada na lógica.
# Relative cost per task (approximate, ~300 input tokens / 20 output):
# Simple classification: gpt-5.6-luna ~$0.0001 vs gpt-5.6-sol ~$0.002
# The right model makes a 25x difference in costs!
def optimized_call(prompt: str, complexity: str) -> str:
"""Chooses the most economical suitable model."""
model = {
"simple": "gpt-5.6-luna",
"standard": "gpt-5.6-terra",
"complex": "gpt-5.6-sol",
}.get(complexity, "gpt-5.6-terra")
response = client.responses.create(model=model, input=prompt)
return response.output_text
2. Colocar respostas em cache
A segunda alavanca é evitar pagar duas vezes pela mesma resposta. Um FAQ, um catálogo de produtos ou um formulário padrão geram pedidos estritamente idênticos dezenas de vezes por dia. A chave da cache combina o modelo, a entrada e os parâmetros — incluir todos eles é essencial, caso contrário, uma alteração na temperatura devolveria silenciosamente a resposta antiga.
import hashlib
class CachedClient:
"""Client with cache to avoid redundant calls."""
def __init__(self):
self.client = OpenAI()
self.cache: dict[str, str] = {}
def create(self, model: str, input: str, **kwargs) -> str:
# Create a cache key
cache_key = hashlib.md5(
f"{model}:{input}:{json.dumps(kwargs, sort_keys=True)}".encode()
).hexdigest()
if cache_key in self.cache:
print("Cache hit!")
return self.cache[cache_key]
response = self.client.responses.create(
model=model, input=input, **kwargs
)
self.cache[cache_key] = response.output_text
return response.output_text
3. Limitar tokens de saída
Por fim, limite a saída sempre que o seu comprimento for previsível. Como a saída é a parte cara, pedir uma única palavra enquanto autoriza dois mil tokens deixa a porta aberta a uma resposta verbosa que irá pagar mas não utilizar.
# Always set max_output_tokens for predictable tasks
response = client.responses.create(
model="gpt-5.6-terra",
input="Classify this text: positive, negative, or neutral.",
max_output_tokens=10 # Expecting a single word
)
Tarifas atualizadas a 5 de agosto de 2026 — os preços mudam regularmente: antes de qualquer cálculo orçamental, verifique a grelha atual na página oficial de preços da OpenAI.
Pontos-chave
- Os custos dependem do modelo E da direção (entrada vs saída)
- Implemente um monitor de custos com alertas de orçamento
- Utilize o modelo certo para cada tarefa: Luna para volume, Terra por padrão
- A cache pode reduzir drasticamente os custos para pedidos repetitivos
- Defina
max_output_tokensquando o comprimento da resposta for previsível - Consulte o painel da OpenAI para o acompanhamento oficial do consumo