Teorainneacha ráta, cuótaí, agus sraitheanna
Ar an leathanach seo
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