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

Όρια ρυθμού, ποσοστώσεις και επίπεδα

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

Όρια ρυθμού, ποσοστώσεις και επίπεδα

Τα όρια ρυθμού (rate limits) ορίζουν πόσα αιτήματα μπορείτε να στείλετε στο API ανά λεπτό. Η κατανόηση και η διαχείριση αυτών των ορίων είναι κρίσιμη για την αποφυγή διακοπών υπηρεσίας σε περιβάλλον παραγωγής. Το χειρότερο σενάριο είναι πάντα το ίδιο: μια ενσωμάτωση που λειτουργούσε άψογα στην ανάπτυξη, όπου στέλνατε τρία αιτήματα ανά λεπτό, τίθεται σε λειτουργία και ξαφνικά επεξεργάζεται μια ουρά με αρκετές χιλιάδες έγγραφα. Τα σφάλματα 429 καταφθάνουν καταιγιστικά και το μισό της επεξεργασίας χάνεται επειδή δεν είχε προβλεφθεί η διαπερατότητα (throughput).

Το σύστημα επιπέδων

Η OpenAI οργανώνει τα όρια σε επίπεδα (tiers) με βάση το ιστορικό χρέωσής σας. Δεν επιλέγετε εσείς το επίπεδό σας· το ξεκλειδώνετε συσσωρεύοντας δαπάνες και περιμένοντας να παρέλθει ένα χρονικό παράθυρο. Αυτή η πρόοδος έχει μια σημαντική πρακτική συνέπεια: ένας λογαριασμός που δημιουργήθηκε μόνο για μια επίδειξη σε πελάτη δεν θα έχει την ίδια χωρητικότητα με τον λογαριασμό παραγωγής σας, ακόμα και αν ο κώδικας είναι ίδιος.

# Tiers determine your limits
# Tier 1: After first successful payment
# Tier 2: After $50 cumulative spend + 7 days
# Tier 3: After $100 cumulative spend + 7 days
# Tier 4: After $250 cumulative spend + 14 days
# Tier 5: After $1000 cumulative spend + 30 days

# Limits increase significantly with each tier

Τύποι ορίων ρυθμού

Ισχύουν ταυτόχρονα τρεις μετρητές και ο πρώτος που θα φτάσετε στο όριό του σας μπλοκάρει. Η επεξεργασία σύντομων κειμένων θα κορέσει το RPM (αιτήματα ανά λεπτό) πολύ πριν από το TPM (tokens ανά λεπτό). Αντιθέτως, η ανάλυση μεγάλων εγγράφων θα εξαντλήσει το TPM ακόμα και αν έχετε στείλει μόνο μερικές δεκάδες αιτήματα. Ελέγχετε πάντα την τάξη μεγέθους των prompts σας πριν καθορίσετε τον βαθμό παραλληλισμού σας.

# 1. RPM — Requests Per Minute
# 2. TPM — Tokens Per Minute
# 3. RPD — Requests Per Day

# Order of magnitude for Tier 3 (check your actual limits
# at platform.openai.com > Settings > Limits):
# RPM: 5,000 requests/minute
# TPM: 2,000,000 tokens/minute
# RPD: 10,000 requests/day

Ανάγνωση των κεφαλίδων ορίων ρυθμού

Δεν χρειάζεται να μαντέψετε την κατανάλωσή σας: κάθε απόκριση τις μεταφέρει στις HTTP κεφαλίδες της. Το SDK τις αποκρύπτει από προεπιλογή για να επιστρέψει μόνο το αναλυμένο αντικείμενο, αλλά το with_raw_response σας δίνει πρόσβαση στην ακατέργαστη απόκριση και το parse() ανακατασκευάζει το συνηθισμένο αντικείμενο. Ένας πίνακας ελέγχου (dashboard) που τροφοδοτείται με αυτές τις τιμές σας προειδοποιεί καθώς πλησιάζετε το ανώτατο όριο, αντί να το ανακαλύψετε μέσω ενός σφάλματος.

from openai import OpenAI
client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Hello!"
)

# Access headers via the raw HTTP response
# Using with_raw_response mode
raw = client.responses.with_raw_response.create(
    model="gpt-5.6-terra",
    input="Hello!"
)

print(f"RPM limit: {raw.headers.get('x-ratelimit-limit-requests')}")
print(f"RPM remaining: {raw.headers.get('x-ratelimit-remaining-requests')}")
print(f"TPM limit: {raw.headers.get('x-ratelimit-limit-tokens')}")
print(f"TPM remaining: {raw.headers.get('x-ratelimit-remaining-tokens')}")
print(f"Reset in: {raw.headers.get('x-ratelimit-reset-requests')}")

response = raw.parse()
print(f"Response: {response.output_text}")

Περιορισμός ρυθμού στην πλευρά του πελάτη

Είναι προτιμότερο να επιβραδύνετε εσείς τον ρυθμό σας παρά να απορριφθείτε. Δύο υλοποιήσεις καλύπτουν τις περισσότερες ανάγκες.

Περιορισμός διαπερατότητας με semaphore

Η πρώτη συνδυάζει ένα semaphore, το οποίο περιορίζει τον αριθμό των ταυτόχρονων κλήσεων, με μια καθυστέρηση που υπολογίζεται από την επιθυμητή διαπερατότητα. Στο παράδειγμα, πενήντα περιλήψεις ξεκινούν ταυτόχρονα, αλλά μόνο πέντε εκτελούνται παράλληλα, με απόσταση την καθυστέρηση που αντιστοιχεί σε 100 αιτήματα ανά λεπτό. Ο κώδικας κλήσης παραμένει ένα απλό asyncio.gather: όλη η πειθαρχία είναι εγκλωβισμένη μέσα στην κλάση.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

class RateLimiter:
    """Limits the number of simultaneous requests."""

    def __init__(self, max_concurrent: int = 10, rpm: int = 500):
        self.semaphore = asyncio.Semaphore(max_concurrent)
        self.rpm = rpm
        self.delay = 60.0 / rpm  # Delay between each request

    async def call(self, prompt: str) -> str:
        async with self.semaphore:
            await asyncio.sleep(self.delay)
            response = await async_client.responses.create(
                model="gpt-5.6-terra",
                input=prompt
            )
            return response.output_text

async def batch_processing():
    limiter = RateLimiter(max_concurrent=5, rpm=100)

    prompts = [f"Summarize concept {i}" for i in range(50)]
    tasks = [limiter.call(p) for p in prompts]
    results = await asyncio.gather(*tasks)

    for i, r in enumerate(results):
        print(f"Result {i}: {r[:50]}...")

# asyncio.run(batch_processing())

Απλός κάδος tokens (Token Bucket)

Ο κάδος tokens είναι πιο ευέλικτος επειδή επιτρέπει εκρήξεις (bursts). Ο κάδος γεμίζει με σταθερό ρυθμό και αδειάζει με κάθε κλήση: αν η εφαρμογή σας έχει αδρανήσει για ένα λεπτό, μπορεί να επανεκκινήσει με πλήρη ταχύτητα για πενήντα αιτήματα και στη συνέχεια να επιστρέψει φυσικά στον ρυθμό πλήρωσης. Αυτή είναι ακριβώς η συμπεριφορά που θέλετε για μια υπηρεσία που εναλλάσσεται μεταξύ αιχμών και υφέσεων, και λειτουργεί σε περιβάλλοντα πολλαπλών νημάτων χάρη στο κλείδωμα (lock).

import time
import threading

class TokenBucket:
    """Rate limiter based on the token bucket algorithm."""

    def __init__(self, tokens_per_second: float, max_capacity: int):
        self.tokens_per_second = tokens_per_second
        self.max_capacity = max_capacity
        self.tokens = max_capacity
        self.last_refill = time.monotonic()
        self.lock = threading.Lock()

    def wait(self, tokens_needed: int = 1):
        """Waits until enough tokens are available."""
        while True:
            with self.lock:
                now = time.monotonic()
                elapsed = now - self.last_refill
                self.tokens = min(
                    self.max_capacity,
                    self.tokens + elapsed * self.tokens_per_second
                )
                self.last_refill = now

                if self.tokens >= tokens_needed:
                    self.tokens -= tokens_needed
                    return

            time.sleep(0.1)

# Usage: max 50 requests per minute
bucket = TokenBucket(tokens_per_second=50/60, max_capacity=50)

def limited_call(prompt: str) -> str:
    bucket.wait(1)
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt
    )
    return response.output_text

Στρατηγικές για μεγάλους όγκους

1. Κατανομή σε πολλαπλά έργα

Κάθε έργο (project) έχει τα δικά του όρια ρυθμού. Αν φτάσετε στο ανώτατο όριό σας ενώ βρίσκεστε ήδη σε υψηλό επίπεδο, η κατανομή των κλήσεων σε πολλαπλά έργα πολλαπλασιάζει μηχανικά τη διαθέσιμη χωρητικότητα. Ο παρακάτω κύκλος round-robin απεικονίζει την αρχή· σε περιβάλλον παραγωγής, μετακινήστε τον κύκλο έξω από τη συνάρτηση ώστε να διατηρείται μεταξύ των κλήσεων.

from openai import OpenAI

# Each project has its own rate limits
clients = [
    OpenAI(project="proj-aaaa"),  # Project 1
    OpenAI(project="proj-bbbb"),  # Project 2
    OpenAI(project="proj-cccc"),  # Project 3
]

def round_robin_call(prompt: str, clients: list) -> str:
    """Distributes calls across multiple projects."""
    import itertools
    client_cycle = itertools.cycle(clients)
    client = next(client_cycle)
    return client.responses.create(
        model="gpt-5.6-terra",
        input=prompt
    ).output_text

2. Χρήση του κατάλληλου μοντέλου για τον κατάλληλο όγκο

Η επιλογή του μοντέλου είναι επίσης μια απόφαση χωρητικότητας, όχι μόνο ποιότητας. Η δέσμευση των βαρύτερων μοντέλων για κρίσιμες εργασίες και η δρομολόγηση του όγκου σε ένα μοντέλο με υψηλότερα όρια ελευθερώνει διαπερατότητα εκεί όπου πραγματικά τη χρειάζεστε.

# Economy models (gpt-5.6-luna) have the highest limits
# Use them for high-volume tasks

# The flagship model (gpt-5.6-sol) has the lowest limits
# Reserve it for critical tasks

3. Ουροποίηση (Queuing)

Τέλος, η ουροποίηση αποσυνδέει την παραγωγή αιτημάτων από την κατανάλωσή τους. Ένα μόνο νήμα εξάγει από την ουρά με σταθερό ρυθμό, ενώ το υπόλοιπο της εφαρμογής υποβάλλει αιτήματα ελεύθερα· ο καλών μπλοκάρεται σε ένα συμβάν (event) μέχρι να φτάσει το αποτέλεσμά του. Αυτό το μοτίβο απορροφά τις αιχμές χωρίς ποτέ να υπερβαίνει τη διαμορφωμένη διαπερατότητα.

import queue
import threading

class APIQueue:
    """Queue for API calls."""

    def __init__(self, rpm: int = 100):
        self.queue = queue.Queue()
        self.delay = 60.0 / rpm
        self.running = True
        self.worker = threading.Thread(target=self._process, daemon=True)
        self.worker.start()

    def _process(self):
        while self.running:
            try:
                prompt, future = self.queue.get(timeout=1)
                response = client.responses.create(
                    model="gpt-5.6-terra",
                    input=prompt
                )
                future["result"] = response.output_text
                future["event"].set()
                time.sleep(self.delay)
            except queue.Empty:
                continue

    def submit(self, prompt: str) -> str:
        future = {"result": None, "event": threading.Event()}
        self.queue.put((prompt, future))
        future["event"].wait()
        return future["result"]

Βασικά σημεία

  • Τα όρια ρυθμού ισχύουν ταυτόχρονα για RPM, TPM και RPD
  • Το επίπεδό σας καθορίζει τα όριά σας· αυξάνεται με τη σωρευτική σας δαπάνη
  • Διαβάζετε τις κεφαλίδες x-ratelimit-* για να γνωρίζετε την κατανάλωσή σας σε πραγματικό χρόνο
  • Υλοποιήστε έναν περιοριστή ρυθμού στην πλευρά του πελάτη για να αποφύγετε τα σφάλματα 429
  • Κατανείμετε το φορτίο σε πολλαπλά έργα για μεγάλους όγκους
  • Το Luna προσφέρει τα υψηλότερα όρια ρυθμού για μαζική επεξεργασία