Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Teorainneacha ráta, cuótaí, agus sraitheanna

Ceacht 13 as 22 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Teorainneacha ráta, cuótaí, agus sraitheanna
  2. An córas sraitheanna
  3. Cineálacha teorainneacha ráta
  4. Ceanntásca teorainn ráta a léamh
  5. Teorainniú ráta ar thaobh an chliaint
  6. Straitéisí do thoirt mhór
  7. Príomhphointí

Teorainneacha ráta, cuótaí, agus sraitheanna

Sainíonn teorainneacha ráta cé mhéad iarratas is féidir leat a sheoladh chuig an API in aghaidh an nóiméid. Tá sé ríthábhachtach na teorainneacha seo a thuiscint agus a bhainistiú chun cur isteach ar an tseirbhís a sheachaint sa timpeallacht táirgeachta. Is ionann an scéal uafásach i gcónaí: comhtháthú a d’oibrigh go foirfe le forbairt, áit ar sheol tú trí iarratas in aghaidh an nóiméid, a théann beo agus a phróiseálann ciú de roinnt mílte doiciméad go tobann. Tagann earráidí 429 i dtuile, agus cailltear leath den phróiseáil toisc nár tuaradh an tréchur.

An córas sraitheanna

Eagraíonn OpenAI teorainneacha i sraitheanna (leibhéil) bunaithe ar do stair bhilleála. Ní roghnaíonn tú do shraith; díghlasálann tú í trí chaiteachas a charnadh agus tríd an bhfuinneog ama a chaitheamh. Tá tionchar praiticiúil tábhachtach ag an dul chun cinn seo: ní bheidh an toilleadh céanna ag cuntas a cruthaíodh go sonrach le haghaidh taispeántais do chliant agus atá ag do chuntas táirgeachta, fiú má tá an cód identic.

# 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

Cineálacha teorainneacha ráta

Baineann trí chuntar i bhfeidhm go comhuaineach, agus bacann an chéad cheann a bhuaileann tú thú. Sáróidh próiseáil téacsanna gairide RPM i bhfad roimh TPM; os a choinne sin, íocfaidh anailís ar dhoiciméid fhada TPM fiú mura bhfuil ach roinnt dosaen iarratas seolta agat. Seiceáil ord méide do leideanna i gcónaí sula ndéanann tú do chomhthreomhaireacht a mhéadú.

# 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

Ceanntásca teorainn ráta a léamh

Ní gá duit do thomhaltas a thuar: iompraíonn gach freagra é ina cheanntásca HTTP. Folaíonn an SDK iad go réamhshocraithe chun an oibiacht pharsáilte a thabhairt ar ais amháin, ach tugann with_raw_response rochtain duit ar an bhfreagra amh, agus athchruthaíonn parse() an ghnáthoibiacht. Rabhaidh painéal deasctha a chothaítear leis na luachanna seo duit agus tú ag druidim leis an uasteorainn in ionad ligean duit é a fháil amach trí earráid.

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}")

Teorainniú ráta ar thaobh an chliaint

Is fearr tú féin a mhoilliú ná diúltú a fháil. Clúdaíonn dhá chur chun feidhme formhór na riachtanas.

Tréchur a theorannú le seafamar

Comhcheanglaíonn an chéad cheann seafamar, a chuireann teorainn le líon na nglaonna comhuaineacha, le moill a ríomhtar ón tréchur spriocdhírithe. Sa sampla, seoltar caoga achoimre ag an am céanna ach ní théann ach cúig cinn ar aghaidh go comhthreomhar, arna scaradh leis an moill a fhreagraíonn do 100 iarratas in aghaidh an nóiméid. Fanann an cód glaonna ina asyncio.gather simplí: tá an disciplín go léir capsúlaithe sa chlás.

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())

Buicéad token simplí

Tá an buicéad token níos solúbtha toisc go gceadaíonn sé pléascanna. Líontar an buicéad ag ráta tairiseach agus folmhaítear é le gach glao: má bhí d’iarratas díomhaoin ar feadh nóiméid, is féidir leis tosú arís ag luas iomlán ar feadh caoga iarratas, agus ansin titim ar ais go nádúrtha chuig an ráta líonta. Is é seo go díreach an iompar atá uait do sheirbhís a athraíonn idir buaicphointí agus tréimhsí ciúin, agus oibríonn sé i dtimpeallachtaí ilsnáithe de bharr an ghlas.

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

Straitéisí do thoirt mhór

1. Dáileadh thar tionscadail iolracha

Tá a theorainneacha ráta féin ag gach tionscadal. Má bhuaileann tú do uasteorainn agus tú cheana féin ar shraith ard, méadaíonn dáileadh glaonna thar thionscadail iolracha an toilleadh atá ar fáil go meicniúil. Léiríonn an timthriall round-robin thíos an prionsabal; sa timpeallacht táirgeachta, bog an timthriall lasmuigh den fheidhm ionas go mairfidh sé idir glaonna.

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. Úsáid a bhaint as an múnla ceart don toirt cheart

Is cinneadh toillte é roghnú an mhúnla chomh maith, ní cinneadh cáilíochta amháin. Trí na samhlacha is troime a chur in áirithe do thascanna criticiúla agus trí thoirt a stiúradh chuig múnla a bhfuil teorainneacha níos airde aige, saoróidh tú tréchur san áit a bhfuil gá leis i ndáiríre.

# 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. Ciúáil

Ar deireadh, déanann ciúáil dícheangal idir táirgeadh iarratas agus tomhaltas. Díchiúálaíonn snáithe amháin ag luas seasta agus cuirfidh an chuid eile den iarratas isteach go saor; fanfaidh an glaoir ar imeacht go dtí go dtagann a thoradh. Súnn an patrún seo buaicphointí gan an tréchur cumraithe a shárú riamh.

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"]

Príomhphointí

  • Baineann teorainneacha ráta i bhfeidhm go comhuaineach i RPM, TPM, agus RPD
  • Cinneann do shraith do theorainneacha – méadaíonn sí le do chaiteachas carnach
  • Léigh ceanntásca x-ratelimit-* chun eolas a bheith agat ar do thomhaltas i bhfíor-am
  • Cuir teorainneoir ráta taobh cliaint i bhfeidhm chun earráidí 429 a sheachaint
  • Dáil an t-ualach thar thionscadail le haghaidh toirteanna móra
  • Tairgeann Luna na teorainneacha ráta is airde le haghaidh próiseála baisce