HI ▾
API कुंजी पाएँ

Unlimited AI API कॉल: रेट लिमिट समझें

क्या आप असीमित AI API कॉल कर सकते हैं? इस API पर कोई मासिक क्वाटा नहीं है, लेकिन दो रेट लिमिट हैं: प्रति मिनट अनुरोध और एक साथ अनुरोध। यहाँ बताया गया है कि वे व्यावहारिक रूप से क्या अर्थ रखते हैं और कोड कैसे लिखें जो उनकी सीमा में रहे।

अपडेट किया गया

मुख्य बिंदु

  • एक पूर्ण कुंजी प्रति मिनट 300 अनुरोध और 8 समानांतर अनुरोधों की अनुमति देती है; एक ट्रायल कुंजी 60 और 2 की अनुमति देती है।
  • कोड rate_limited के साथ 429 का अर्थ प्रति मिनट अधिक अनुरोध हैं; कोड concurrency का अर्थ एक साथ अधिक अनुरोध हैं।
  • एक स्ट्रीम किए गए अनुरोध में स्ट्रीम समाप्त होने तक उसकी कंकरेंसी स्लॉट बनी रहती है।
  • 8 का सेमाफोर उपयोग करें और बैकऑफ़ के साथ 429 को पुनः प्रयास करें, Retry-After का सम्मान करते हुए।
एक गेट के माध्यम से कतार में लगते डेटा पैकेट के आठ लेन, API रेट लिमिट और कंकरेंसी को दर्शाते हुए
सिक्कों के खिलाफ चमकते टोकन घनों के सामने संतुलन, टोकन-प्रति API लागत को दर्शाता है

दोनों सीमाएँ, एक साथ

अनलिमिटेड एपीआई कॉल्स के लिए, "मासिक कैप" के अर्थ में, आप सुरक्षित हैं: बिलिंग प्रीपेड और टोकन-आधारित है, बिना कॉल क्वाटा के। थ्रूपुट को सीमित करने वाली दो रेट लिमिट्स हैं जो शेयर्ड GPU की रक्षा करती हैं।

कुंजी का प्रकारप्रति मिनट अनुरोधसमानांतर अनुरोध
पूर्ण कुंजी3008
ट्रायल कुंजी602

अन्य निश्चित सीमाएँ: 8 MB तक का अनुरोध बॉडी और 100,000 टोकन की कॉन्टेक्स्ट विंडो (प्रॉम्प्ट और कम्प्लीशन)। ये प्रति अनुरोध लागू होते हैं, प्रति मिनट नहीं।

दोनों रेट लिमिट्स स्वतंत्र हैं। आप कॉन्करेंसी लिमिट तोड़ सकते हैं जबकि प्रति मिनट केवल 20 रिक्वेस्ट भेज रहे हों यदि प्रत्येक रिक्वेस्ट लंबा चल रहा हो, और आप बहुत तेज़, छोटी कॉल्स के साथ प्रति-मिनट लिमिट तोड़ सकते हैं।

वास्तविक वर्कलोड के लिए संख्याओं का अर्थ

अपने वर्कलोड का आकार तय करने का एक तेज़ तरीका लिटिल का नियम है: कॉन्करेंट रिक्वेस्ट = आगमन दर x औसत अवधि।

  • चैटबॉट, 100 सक्रिय उपयोगकर्ता। यदि प्रत्येक 60 सेकंड में एक संदेश भेजता है, तो यह प्रति मिनट 100 अनुरोध हैं, जो 300 से काफी कम हैं। प्रत्येक जवाब लगभग 10 सेकंड लेता है, इसलिए औसत कन्करेंसी (100 / 60) x 10, लगभग 17 है। यह 8 से अधिक है, इसलिए आपको क्यूइंग की आवश्यकता है, न कि केवल रीट्राई लूप।
  • 10,000 छोटे प्रॉम्प्ट्स का बैच। प्रति मिनट 300 की दर से न्यूनतम रन टाइम 10,000 / 300 = 33.3 मिनट है। प्रति मिनट 300 तक पहुँचने के लिए 8 स्लॉट्स के साथ, कॉल्स का औसत 1.6 सेकंड होना चाहिए (8 x 60 / 300)। लंबी कॉल्स बॉटलनेक को कॉन्करेंसी की ओर ले जाती हैं: प्रति कॉल 8 सेकंड पर, 8 स्लॉट्स प्रति मिनट 60 कॉल्स देते हैं और जॉब लगभग 167 मिनट लेती है।
  • एकल डेवलपर स्क्रिप्टिंग। एक या दो रिक्वेस्ट एक साथ दोनों सीमाओं से कहीं दूर रहते हैं।

सीख यह है कि लंबी जनरेशन के लिए, कन्करेंसी लगभग हमेशा वह सीमा होती है जिसे आप सबसे पहले छूते हैं। छोटे आउटपुट प्रति-मिनट की छत को छूते हैं।

रेट-लिमिट हेडर्स पढ़ना

प्रत्येक रिस्पॉन्स में हेडर्स होते हैं जिन्हें आप लॉग कर सकते हैं या अनुकूलित करने के लिए उपयोग कर सकते हैं:

  • X-RateLimit-Limit-Requests: आपकी प्रति-मिनट लिमिट।
  • X-RateLimit-Limit-Concurrency: आपकी कॉन्करेंट लिमिट।
  • X-Balance-USD: शेष क्रेडिट।
  • X-Request-Id: यदि कुछ गलत दिखे तो सपोर्ट के लिए इसे उद्धृत करें।

OpenAI Python SDK के साथ, उन्हें देखने के लिए रिस्पॉन्स रैपर का उपयोग करें:

from openai import OpenAI

client = OpenAI(base_url="https://api.unlimitedaiapi.com/v1", api_key="YOUR_KEY")

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Reply with one word."}],
)
print(raw.headers.get("X-RateLimit-Limit-Requests"))
print(raw.headers.get("X-RateLimit-Limit-Concurrency"))
print(raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)

शुरुआत में एक बार इनकी जाँच करें और 8 को हार्ड-कोड करने के बजाय कॉन्करेंसी मान से अपने वर्कर पूल का आकार तय करें। इस तरह उसी कोड का उपयोग ट्रायल कुंजी और पूर्ण कुंजी दोनों के लिए किया जा सकता है।

429 आपको क्या बताता है

किसी लिमिट से अधिक जाने पर HTTP 429 लौटाया जाता है जिसमें एक एरर कोड होता है:

  • rate_limited: प्रति मिनट बहुत सारे अनुरोध। गति धीमी करें।
  • concurrency: प्रगति में अनुरोध अधिक हैं। एक को समाप्त होने दें।

एपीआई अस्थायी रूप से ओवरलोड होने पर 429 भी Retry-After: 5 हेडर के साथ लौटाता है। हर मामले में सही प्रतिक्रिया समान है: प्रतीक्षा करें, फिर फिर से प्रयास करें, जब उपस्थित हो तो हेडर मान का उपयोग करें।

स्ट्रीमिंग के साथ एक फँद: एक स्ट्रीम किए गए अनुरोध की कन्करेंसी स्लॉट स्ट्रीम समाप्त होने तक बनी रहती है। यदि कोई क्लाइंट एक स्ट्रीम खोलता है और फिर पढ़ना बंद कर देता है, या एक UI कनेक्शन लटकाए रखता है, तो वे स्लॉट व्यस्त रहते हैं। हमेशा उन स्ट्रीम को बंद करें जिन्हें आप छोड़ रहे हैं।

एक बैच रनर जो दोनों सीमाओं का सम्मान करता है

यह स्क्रिप्ट एक समय में अधिकतम 8 अनुरोध भेजती है, शुरुआत को इस तरह फैलाती है कि प्रति मिनट 300 से कम रहें, और बैकऑफ़ के साथ 429 पर रीट्राई करती है। ट्रायल कुंजी के लिए CONCURRENCY और RPM को समायोजित करें।

import asyncio, random
from openai import AsyncOpenAI, RateLimitError

client = AsyncOpenAI(base_url="https://api.unlimitedaiapi.com/v1", api_key="YOUR_KEY", max_retries=0)
CONCURRENCY, RPM = 8, 300
sem = asyncio.Semaphore(CONCURRENCY)
interval = 60 / RPM  # 0.2 s between starts

async def call(prompt, attempt=0):
    async with sem:
        try:
            r = await client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            return r.choices[0].message.content
        except RateLimitError as e:
            if attempt >= 6:
                raise
            wait = float(e.response.headers.get("Retry-After", 5)) + random.random()
            await asyncio.sleep(wait * (1.5 ** attempt))
    return await call(prompt, attempt + 1)

async def main(prompts):
    tasks = []
    for p in prompts:
        tasks.append(asyncio.create_task(call(p)))
        await asyncio.sleep(interval)
    return await asyncio.gather(*tasks)

results = asyncio.run(main(["Summarise: ..."] * 50))

सेमाफोर 429 पर विराम अवस्था में होने पर जारी किया जाता है, इसलिए अन्य टास्क आगे बढ़ते रहते हैं। क्लाइंट पर max_retries=0 सेट करने से SDK को आपके रीट्राई के ऊपर अपने खुद के छिपे हुए रीट्राई करने से रोकता है।

उच्च वॉल्यूम के लिए डिज़ाइन टिप्स

  • क्यू, फैन आउट न करें। 8 वर्कर्स के साथ एक जॉब क्यू, प्रति अनुरोध थ्रेड स्पॉन करने और रीट्राई करने से बेहतर है।
  • जिटर जोड़ें। यदि कई वर्कर्स समान समय के लिए बैकऑफ़ करते हैं, तो वे सभी एक साथ लौटते हैं और फिर टकराते हैं।
  • आउटपुट को कैप करें। max_tokens सेट करने से कॉल की अवधि कम होती है, जो कॉन्करेंसी कैप के तहत प्रभावी थ्रूपुट बढ़ाती है।
  • कम, बड़े प्रॉम्प्ट्स को प्राथमिकता दें जब कार्य अनुमति दे, उदाहरण के लिए प्रति अनुरोध 20 आइटम क्लासिफाई करने के बजाय एक। इससे अनुरोध संख्या 20x कम हो जाती है। 100,000 टोकन विंडो का ध्यान रखें।
  • गति के साथ लागत ट्रैक करें। 1M इनपुट टोकन के लिए $0.15 और 1M आउटपुट टोकन के लिए $0.50 पर, 2,000 टोकन इनपुट और 300 आउटपुट वाले 10,000 अनुरोधों वाले जॉब की लागत $4.50 है। टॉप-अप राशि और बोनस के लिए मूल्य निर्धारण पेज देखें।

यदि आपकी उत्पाद के लिए पूर्ण-कुंजी सीमाएँ बहुत कम हैं, तो सहायता पृष्ठ पर अपनी अपेक्षित अनुरोध दर और औसत आउटपुट लंबाई बताकर इसे बताएं।

ऐसी सामान्य गलतियां जो सीमाएं लगती हैं

कुछ विफलताएं रेट लिमिटिंग जैसी लगती हैं लेकिन उनका कारण अलग होता है।

रीट्राई स्टॉर्म्स

हर 429 पर तुरंत रेट्राइ करने वाला क्लाइंट समस्या को बदतर बनाता है। बिना विलंब के रिट्राइ करने वाले दस वर्कर्स प्रति मिनट काउंटर को छत पर पिन रखते हैं, इसलिए उनमें से कोई भी सफल नहीं होता। वॉल्यूम पर जिटर के साथ बैकऑफ़ वैकल्पिक नहीं है।

अनुरोधों की गिनती, प्रयासों की नहीं

आपके रीट्राई भी अनुरोध के रूप में गिने जाते हैं। यदि आपकी योजना प्रति मिनट 300 है और कॉल्स का 20% रीट्राई किया जाता है, तो आपकी वास्तविक मांग 360 है। इसे बजट करने के लिए स्टार्टर लूप को सीमा के लगभग 80% पर चलाएं, उदाहरण के लिए प्रति मिनट 240।

टाइमआउट्स जो काम रद्द करते हैं

यदि आपका क्लाइंट 30 सेकंड के बाद हार मान लेता है लेकिन सर्वर अभी भी जनरेट कर रहा है, तो आप पहली वाली स्लॉट पकड़े हुए होने के दौरान एक प्रतिस्थापन अनुरोध खोल सकते हैं। क्लाइंट टाइमआउट को अपनी सबसे लंबी अपेक्षित जनरेशन से ऊपर सेट करें, या max_tokens कम करें।

त्वरित मैनुअल टेस्ट

ट्रायल कुंजी के साथ जानबूझकर एक सीमा ट्रिगर देखने के लिए, एक ही समय में तीन अनुरोध भेजें:

for i in 1 2 3; do
  curl -s -o /dev/null -w "%{http_code}
" https://api.unlimitedaiapi.com/v1/chat/completions     -H "Authorization: Bearer YOUR_KEY" -H "Content-Type: application/json"     -d '{"model":"uncensored","messages":[{"role":"user","content":"Write a 300 word story."}]}' &
done; wait

ट्रायल कुंजी (2 कॉन्करेंट) पर आपको दो 200 प्रतिक्रियाएं और एक 429 दिखनी चाहिए।

आगे कहाँ जाएँ

एक कुंजी API कुंजी पेज पर प्राप्त करें; वन-क्लिक ट्रायल क्रेडिट वास्तविक 429 त्रुटियों के खिलाफ आपकी रीट्राई लॉजिक का परीक्षण करने के लिए पर्याप्त है, क्योंकि ट्रायल कुंजी का 60 प्रति मिनट और 2 समानांतर सीमा जानबूझकर आसानी से पार किया जा सकता है। दस्तावेज़ में हर एंडपॉइंट सूचीबद्ध है, और LangChain और एजेंट नोट्स दिखाते हैं कि एजेंट फ्रेमवर्क के अंदर कॉन्करेंसी को कैसे सीमित करें, जहाँ एक उपयोगकर्ता कार्य कई समानांतर कॉल्स को प्रारंभ कर सकता है।

प्रश्न और उत्तर

क्या API कॉल पर कोई दैनिक या मासिक सीमा है?

नहीं। बिलिंग टोकन के आधार पर प्रीपेड है और कॉल क्वाटा नहीं है। केवल प्रति-मिनट और कॉन्करेंसी लिमिट लागू होते हैं।

जब मैं प्रति मिनट 300 अनुरोधों से अधिक हो जाता हूँ तो क्या होता है?

API HTTP 429 त्रुटि कोड rate_limited के साथ उत्तर देता है। प्रतीक्षा करें और पुनः प्रयास करें, यदि उपलब्ध हो तो Retry-After हेडर का उपयोग करें।

कम ट्राफिक के साथ मुझे कॉन्करेंसी त्रुटि क्यों मिलती है?

लंबी जनरेशन और खुले स्ट्रीम अपनी जगह तब तक रखते हैं जब तक वे समाप्त नहीं हो जाते। आठ धीमे अनुरोध एक पूरी कुंजी भरने के लिए पर्याप्त हैं, इसलिए max_tokens को सीमित करें और उपयोग न होने वाले स्ट्रीम बंद करें।

क्या 429 प्रतिक्रियाओं के लिए शुल्क लिया जाता है?

नहीं। विफल या अस्वीकृत अनुरोधों पर कोई शुल्क नहीं लगाया जाता।

आपकी कुंजी बस एक फ़ॉर्म दूर है

एक खाता बनाएँ, कुंजी कॉपी करें, बेस URL बदलें। सेटअप यही है।

API कुंजी पाएँ