Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Παρακολούθηση κόστους και χρήσης

Μάθημα 16 / 22 Ενημερώθηκε 29 Ιουλίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Παρακολούθηση κόστους και χρήσης
  2. Κατανόηση της χρέωσης
  3. Υπολογιστής κόστους
  4. Παρακολούθηση κόστους σε πραγματικό χρόνο
  5. Πελάτης με έλεγχο προϋπολογισμού
  6. Βελτιστοποίηση κόστους
  7. Βασικά σημεία

Παρακολούθηση κόστους και χρήσης

Το κόστος του 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 για την επίσημη παρακολούθηση κατανάλωσης