Παρακολούθηση κόστους και χρήσης
Σε αυτήν τη σελίδα
Παρακολούθηση κόστους και χρήσης
Το κόστος του API μπορεί να ξεφύγει γρήγορα από τον έλεγχο αν δεν το παρακολουθείτε. Αυτό το μάθημα σας διδάσκει πώς να εντοπίζετε, να εκτιμάτε και να ελέγχετε τις δαπάνες σας σε περιβάλλον παραγωγής. Η ιστορία επαναλαμβάνεται από έργο σε έργο: μια λειτουργία τίθεται σε λειτουργία την Πέμπτη, κανείς δεν ελέγχει τον πίνακα ελέγχου το σαββατοκύριακο και το πρωί της Δευτέρας ο λογαριασμός ισούται με ολόκληρο τον μηνιαίο προϋπολογισμό. Τα παρακάτω βήματα σας βοηθούν να εντοπίσετε την απόκλιση κόστους τη στιγμή που συμβαίνει, και όχι τριάντα ημέρες αργότερα.
Κατανόηση της χρέωσης
Το κόστος υπολογίζεται ανά εκατομμύριο tokens, με διαφορετικές τιμές για την είσοδο (input) και την έξοδο (output). Αυτή η ασυμμετρία έχει άμεσες συνέπειες στις επιλογές σχεδιασμού σας: η αποστολή ενός μεγάλου εγγράφου ως είσοδος κοστίζει σημαντικά λιγότερο από το να ζητήσετε από το μοντέλο να παράγει ένα μεγάλο κείμενο. Κάθε απάντηση επιστρέφει τον ακριβή αριθμό και για τις δύο κατευθύνσεις, οπότε δεν χρειάζεται ποτέ να κάνετε εκτιμήσεις.
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!
Υπολογιστής κόστους
Η μετατροπή αυτών των μετρητών σε δολάρια απαιτεί έναν πίνακα τιμολόγησης. Μονώστε τον σε μια αφιερωμένη δομή αντί να διασκορπίζετε σταθερές σε όλο τον κώδικά σας: όταν αλλάζουν οι τιμές ή προσθέτετε ένα μοντέλο, χρειάζεται να τροποποιήσετε μόνο μία γραμμή. Οι παρακάτω τιμές είναι ενδεικτικές και πρέπει να επαληθεύονται κατά κάθε αναθεώρηση του προϋπολογισμού.
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
Τα οκτώ δέκατα του σεντ ανά κλήση ακούγονται καθησυχαστικά μέχρι να τα πολλαπλασιάσετε με τις πενήντα χιλιάδες ημερήσιες κλήσεις ενός chatbot παραγωγής· αυτό σημαίνει τετρακόσια δολάρια την ημέρα. Να αποκτάτε πάντα τη συνήθεια να σκέφτεστε με βάση τους μηνιαίους όγκους, ποτέ ανά κλήση.
Παρακολούθηση κόστους σε πραγματικό χρόνο
Οι υπολογισμοί ανά μονάδα είναι άχρηστοι αν δεν συγκεντρώνονται. Αυτός ο ιχνηλάτης συγκεντρώνει τις δαπάνες σε τρεις άξονες—ανά ημέρα, ανά μοντέλο και ανά αριθμό κλήσεων—και συγκρίνει το ημερήσιο σύνολο με έναν προϋπολογισμό που ορίζετε εσείς. Οι ειδοποιήσεις είναι διαβαθμισμένες: μια προειδοποίηση όταν απομένει λιγότερο από το 20% του προϋπολογισμού, ακολουθούμενη από μια αυστηρή ειδοποίηση κατά την υπέρβαση του ορίου. Αυτό το ενδιάμεσο βήμα είναι πολύτιμο επειδή σας δίνει χρόνο να παρέμβετε πριν διακοπεί η υπηρεσία.
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))
Πελάτης με έλεγχο προϋπολογισμού
Η παρακολούθηση δεν αρκεί πάντα:απέναντι σε έναν ελαττωματικό βρόχο που καλεί συνεχώς το API, χρειάζεστε έναν οικονομικό διακόπτη ασφαλείας (circuit breaker). Αυτός ο πελάτης ελέγχει τον εναπομείναντα προϋπολογισμό πριν εκδώσει το αίτημα και απορρίπτει κατηγορηματικά την κλήση αν ο φάκελος έχει εξαντληθεί. Η υπηρεσία υποβαθμίζεται, αλλά με ελεγχόμενο τρόπο και χωρίς εκπλήξεις στον λογαριασμό. Η λογιστική κόστους γίνεται εκ των υστέρων, μόλις γίνει γνωστή η πραγματική χρήση.
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}")
Βελτιστοποίηση κόστους
1. Επιλογή του κατάλληλου μοντέλου
Ο πιο ισχυρός μοχλός παραμένει η δρομολόγηση βάσει πολυπλοκότητας. Μια εργασία ταξινόμησης τριών κατηγοριών δεν έχει ανάγκη το ακριβότερο μοντέλο: για αυτή την εργασία, η διαφορά στον λογαριασμό φτάνει τον συντελεστή είκοσι πέντε για ίδια ποιότητα. Κάντε την πολυπλοκότητα ρητή παράμετρο της συνάρτησής σας αντί για απόφαση κωδικοποιημένη στη λογική.
# 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. Αποθήκευση απαντήσεων στην cache
Ο δεύτερος μοχλός είναι η αποφυγή πληρωμής δύο φορές για την ίδια απάντηση. Ένα FAQ, ένας κατάλογος προϊόντων ή μια τυπική φόρμα παράγουν αυστηρά πανομοιότυπα prompts δεκάδες φορές την ημέρα. Το κλειδί της cache συνδυάζει το μοντέλο, την είσοδο και τις παραμέτρους—η συμπερίληψη όλων τους είναι απαραίτητη, διαφορετικά μια αλλαγή στη θερμοκρασία θα επέστρεφε σιωπηλά την παλιά απάντηση.
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. Περιορισμός των tokens εξόδου
Τέλος, θέστε ένα ανώτατο όριο στην έξοδο όποτε το μήκος της είναι προβλέψιμο. Δεδομένου ότι η έξοδος είναι το ακριβό μέρος, το να ζητήσετε μια λέξη ενώ επιτρέπετε δύο χιλιάδες tokens αφήνει την πόρτα ανοιχτή για μια verbose απάντηση που θα πληρώσετε αλλά δεν θα χρησιμοποιήσετε.
# 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
)
Τιμές της 5ης Αυγούστου 2026 — οι τιμές αλλάζουν τακτικά: πριν από οποιονδήποτε υπολογισμό προϋπολογισμού, επαληθεύστε τον τρέχοντα πίνακα στην επίσημη σελίδα τιμολόγησης της OpenAI.
Βασικά σημεία
- Το κόστος εξαρτάται από το μοντέλο ΚΑΙ την κατεύθυνση (είσοδος έναντι εξόδου)
- Υλοποιήστε έναν ιχνηλάτη κόστους με ειδοποιήσεις προϋπολογισμού
- Χρησιμοποιήστε το κατάλληλο μοντέλο για κάθε εργασία: Luna για όγκο, Terra ως προεπιλογή
- Η cache μπορεί να μειώσει δραματικά το κόστος για επαναλαμβανόμενα αιτήματα
- Ορίστε το
max_output_tokensόταν το μήκος της απάντησης είναι προβλέψιμο - Ελέγξτε τον πίνακα ελέγχου της OpenAI για την επίσημη παρακολούθηση κατανάλωσης