Мониторинг на разходите и използването
На тази страница
Мониторинг на разходите и използването
Разходите за API могат бързо да излязат извън контрол, ако не ги следите внимателно. В този урок ще научите как да проследявате, оценявате и контролирате разходите си в продукционна среда. Историята се повтаря от проект на проект: функция се пуска в четвъртък, никой не проверява таблото с данни през уикенда и в понеделник сутринта фактурата отговаря на целия месечен бюджет. Стъпките по-долу ще Ви помогнат да откриете отклонение в разходите в момента, в който се случи, а не тридесет дни по-късно.
Разбиране на таксуването
Разходите се изчисляват на милион токена, като има различни цени за входни (input) и изходни (output) данни. Тази асиметрия има пряко влияние върху избора Ви за архитектура: изпращането на дълъг документ като вход струва значително по-малко от това моделът да генерира дълъг отговор. Всеки отговор връща точния брой токени и в двете посоки, така че никога не се налага да правите приблизителни оценки.
from openai import OpenAI
client = OpenAI()
# Всеки отговор включва метрики за използване
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}")
# Изходните токени струват повече от входните!
Калкулатор за разходи
Превръщането на тези броячи в долари изисква ценова листа. Изолирайте я в отделна структура, вместо да разпръсквате константи из целия си код: когато цените се променят или добавите нов модел, ще трябва да модифицирате само един ред. Посочените по-долу тарифи са ориентировъчни и трябва да се проверяват при всеки преглед на бюджета.
from dataclasses import dataclass
@dataclass
class ModelRate:
input_per_million: float
output_per_million: float
# Приблизителни цени в USD на милион токена
# Винаги проверявайте актуалните цени на 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:
"""Изчислява цената на заявката в 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
# Пример
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Cost: ${cost:.6f}")
# Резултат: Cost: $0.008000
Осем десети от цента на заявка звучат успокояващо, докато не умножите тази сума по петдесетте хиляди ежедневни обаждания на един продукционен чатбот – това са четиристотин долара на ден. Винаги създавайте навик да мислите в месечни обеми, а не за отделна заявка.
Тракер за разходи в реално време
Изчисленията на единица са безполезни, ако не се агрегират. Този тракер обединява разходите по три оси – по ден, по модел и по брой обаждания – и сравнява дневния общ сбор с бюджета, който сте задали. Предупрежденията са йерархични: предупреждение, когато остава по-малко от 20% от бюджета, последвано от строго предупреждение при надхвърляне на лимита. Тази междинна стъпка е ценна, защото Ви дава време да реагирате, преди услугата да бъде прекъсната.
import json
from datetime import datetime, date
from collections import defaultdict
class CostTracker:
"""Проследяване на разходите за API в реално време."""
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):
"""Записва разходите за дадено обаждане."""
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:
"""Връща оставащия бюджет за днес."""
today = date.today().isoformat()
return self.daily_budget - self.costs_per_day[today]
def budget_alert(self) -> bool:
"""Проверява дали бюджетът е близо до лимита."""
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:
"""Генерира отчет за разходите."""
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,
}
# Използване
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))
Клиент с контрол на бюджета
Мониторингът не винаги е достатъчен: пред лицето на дефектен цикъл, който непрекъснато извиква API, Ви е необходим финансов предпазител (circuit breaker). Този клиент проверява оставащия бюджет преди да издаде заявката и категорично отказва обаждането, ако лимитът е изчерпан. Услугата се деградира, но по контролиран начин, без изненадващи фактури. Отчитането на разходите се извършва впоследствие, след като реалното използване стане известно.
class BudgetControlledClient:
"""Клиент, който отказва обаждания, ако бюджетът е надхвърлен."""
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 обаждане с контрол на бюджета."""
# Проверка на бюджета преди обаждането
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
)
# Предупреждение, ако бюджетът е нисък
self.tracker.budget_alert()
return response
# Използване
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}")
Оптимизиране на разходите
1. Избор на правилния модел
Най-мощният лост остава насочването според сложността на задачата. Задача за класификация в три категории няма нужда от най-скъпия модел: за тази задача разликата във фактурата достига фактор двадесет и пет при идентично качество. Направете сложността изричен параметър на Вашата функция, вместо решение, вградено в логиката.
# Относителна цена на задача (приблизително, ~300 входни токена / 20 изходни):
# Проста класификация: gpt-5.6-luna ~$0.0001 спрямо gpt-5.6-sol ~$0.002
# Правилният модел прави разлика от 25 пъти в разходите!
def optimized_call(prompt: str, complexity: str) -> str:
"""Избира най-икономичния подходящ модел."""
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. Кеш на отговорите
Вторият лост е избягването на плащане два пъти за един и същи отговор. ЧЗВ, каталог с продукти или стандартен формуляр генерират строго идентични подкани десетки пъти на ден. Ключът на кеша комбинира модела, входа и параметрите – включването на всички тях е от съществено значение, в противен случай промяна в температурата би върнала тихо стария отговор.
import hashlib
class CachedClient:
"""Клиент с кеш за избягване на излишни обаждания."""
def __init__(self):
self.client = OpenAI()
self.cache: dict[str, str] = {}
def create(self, model: str, input: str, **kwargs) -> str:
# Създаване на ключ за кеша
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. Ограничаване на изходните токени
Накрая, ограничавайте изхода винаги, когато дължината му е предвидима. Тъй като изходът е скъпата част, искането на една дума, докато разрешавате две хиляди токена, оставя вратата отворена за многословен отговор, за който ще платите, но няма да използвате.
# Винаги задавайте max_output_tokens за предвидими задачи
response = client.responses.create(
model="gpt-5.6-terra",
input="Classify this text: positive, negative, or neutral.",
max_output_tokens=10 # Очаква се една дума
)
Тарифи към 5 август 2026 г. – цените се променят редовно: преди всяко изчисление на бюджета проверете актуалната ценова листа на официалната страница за цени на OpenAI.
Ключови изводи
- Разходите зависят от модела И от посоката (вход спрямо изход)
- Внедрете тракер за разходи с предупреждения за бюджета
- Използвайте правилния модел за всяка задача: Luna за големи обеми, Terra по подразбиране
- Кеширането може драстично да намали разходите за повтарящи се заявки
- Задавайте
max_output_tokens, когато дължината на отговора е предвидима - Проверете таблото с данни на OpenAI за официално проследяване на потреблението