HI ▾

API रेट लिमिट क्या है? लिमिट, रीट्राइज़, कॉन्टेक्स्ट

एक रेट लिमिट किसी कुंजी द्वारा एक API पर दिए गए समय में भेजे जाने वाले ट्रैफ़िक की मात्रा को सीमित करता है। यह पृष्ठ व्यावहारिक रूप से API रेट लिमिट क्या है, इसे कोड में कैसे संभालें, और इस API पर लिमिट क्या हैं, यह समझाता है।

अद्यतन

हल्के पैकेट्स को गुजरने के आठ लेन वाले गेट, API रेट लिमिट और कन्करेंसी को दर्शाता है

मुख्य बिंदु

  • एक रेट लिमिट प्रति मिनट अनुरोधों या चल रहे अनुरोधों को सीमित करता है, इसलिए एक क्लाइंट सेवा को ओवरलोड नहीं कर सकता।
  • रेट लिमिट, कॉन्टेक्स्ट विंडो से अलग हैं: एक ट्रैफ़िक को सीमित करता है, दूसरा एकल अनुरोध के आकार को।
  • फुल कुंजी: 8 समानांतर अनुरोध और प्रति मिनट 300। ट्रायल कुंजी: 2 समानांतर और प्रति मिनट 60।
  • कॉन्करेंसी कैप, बैकऑफ़ के साथ पुन: प्रयास और प्रतिक्रिया हेडर की जाँच से लिमिट को संभालें।

रेट लिमिट क्या है

तो, API रेट लिमिट क्या है? यह एक नियम है जो बताता है कि एक खाते या कुंजी एक समय विंडो में कितने कॉल कर सकती है, या एक साथ कितने चला सकती है। यदि आप उससे अधिक हो जाते हैं, तो सर्वर अतिरिक्त कॉल को अस्वीकार कर देता है। अधिकांश HTTP API इसे 429 (Too Many Requests) स्टेटस कोड के साथ संकेत देते हैं, और कई आपको बताते हैं कि कब पुन: प्रयास करें। प्रत्येक सेवा के सटीक व्यवहार के लिए दस्तावेज़ जाँचें।

लिमिट इसलिए मौजूद हैं क्योंकि एक मॉडल सर्वर के पास कंप्यूट की एक निश्चित मात्रा होती है। उनके बिना, एक स्क्रिप्ट एक तंग लूप में सभी को धीमा कर सकती है। एक डेवलपर के रूप में, इसका मतलब दो बातें हैंंं: आपके कोड को अस्वीकृतियों की उम्मीद करनी चाहिए और उनसे उबरना चाहिए, और आपके डिज़ाइन को काम को एक साथ फायर करने के बजाय फैलाना चाहिए।

वे तीन प्रकार की लिमिटें जिनसे आप मिलेंगे

प्रदाता इन्हें मिलाते-जोड़ते हैं, इसलिए अपनी कुंजी के लिए कौन से लागू होते हैं, पढ़ें।

प्रकारइसमें क्या गिना जाता हैसामान्य प्रभाव
प्रति मिनट अनुरोधरोलिंग मिनट में शुरू किए गए कॉलहर कॉल छोटा होने के बावजूद बर्स्ट अस्वीकार कर दिए जाते हैं
कन्करेंसीएक ही समय में चल रहे कॉलकैप से परे समानांतर वर्कर अस्वीकार या कतार में डाले जाते हैं
टोकन या खर्च कोटाप्रति मिनट, दिन या माह उपयोग किए गए टोकन या पैसेबड़े प्रॉम्प्ट छोटे प्रॉम्प्ट की तुलना में जल्दी कैप पर पहुँचते हैं

साधारण API की तुलना में भाषा मॉडल के लिए कॉन्करेंसी अधिक महत्वपूर्ण है, क्योंकि एकल पूर्णता में कई सेकंड लग सकते हैं। दस वर्कर लंबी प्रतिक्रिया का इंतज़ार कर रहे होते हैं, तो वे पूरे समय दस स्लॉट पकड़े रखते हैं।

इस API पर लिमिट

यह API प्रति कुंजी प्रति मिनट अनुरोधों और कॉन्करेंसी को सीमित करता है:

कुंजी का प्रकारकन्करेंसीप्रति मिनट अनुरोध
फुल कुंजी (क्रेडिट के साथ)8300
ट्रायल कुंजी260

दो अन्य संख्याएँ जानने योग्य हैं। अधिकतम अनुरोध बॉडी 8 MB है, और हर प्रतिक्रिया में वे हेडर होते हैं जिन्हें आप पढ़ सकते हैं: X-Request-Id मदद माँगते समय कॉल की पहचान करने के लिए, X-Balance-USD आपके शेष क्रेडिट के लिए, और X-RateLimit-Limit-Requests तथा X-RateLimit-Limit-Concurrency उस कुंजी पर लागू सीमाओं के लिए। आप इन्हें curl के साथ देख सकते हैं:

curl -i https://api.abliteratedapi.com/v1/chat/completions   -H "Authorization: Bearer $ABLITERATED_API_KEY"   -H "Content-Type: application/json"   -d '{"model":"uncensored","max_tokens":5,"messages":[{"role":"user","content":"Hi"}]}'

सीमाएँ आपके द्वारा उपयोग किए जाने वाले क्लाइंट से स्वतंत्र हैं; API OpenAI-संगत है, इसलिए Base URL को https://api.abliteratedapi.com/v1 में बदलते ही कोई भी OpenAI SDK काम करता है।

आप वास्तव में किस सीमा को पार करेंगे?

दोनों संख्याओं को विभाजित करें। एक पूर्ण कुंजी एक साथ 8 अनुरोध और प्रति मिनट 300 अनुरोध चला सकती है, जिसका अर्थ है प्रति सेकंड औसतन 5 अनुरोध। प्रति मिनट 300 तक पहुँचने के लिए, केवल 8 चलते हुए अनुरोधों के साथ, हर कॉल को औसतन 1.6 सेकंड में समाप्त होना चाहिए (8 x 60 / 300)। भाषा मॉडल से प्रतिक्रियाएँ आमतौर पर उससे अधिक समय लेती हैं जब वे कुछ वाक्यों से अधिक लंबी हों, इसलिए पूर्ण कुंजी पर कन्करेंसी लिमिट पहले लागू होती है।

एक काल्पनिक मामले पर विचार करें जहाँ औसत कॉल की अवधि 10 सेकंड है। आठ स्लॉट आपको प्रति मिनट 8 x 60 / 10 = 48 अनुरोध देते हैं, जो 300 से काफी कम है। एक ट्रायल कुंजी पर उसी तर्क का उपयोग करें: 2 स्लॉट और प्रति मिनट 60 की सीमा का अर्थ है कि प्रति मिनट की सीमा लागू होने से पहले कॉल 2 सेकंड से कम समय में पूरी होनी चाहिए। ये अवधियाँ केवल एक उदाहरण हैं, माप नहीं। अपनी कॉल का समय मापें और वास्तविक संख्या का उपयोग करें।

व्यावहारिक सलाह: अपने वर्कर पूल को अनुरोध सीमा के बजाय कन्करेंसी लिमिट के अनुसार सेट करें, और प्रति मिनट की सीमा को सुरक्षा नेट के रूप में कार्य करने दें।

कोड में सीमाओं को कैसे हैंडल करें

तीन आदतें लगभग हर मामले को कवर करती हैं।

  1. समानांतरता को स्वयं सीमित करें। एक सेमाफोर जो आपकी कन्करेंसी लिमिट के बराबर है, इसका अर्थ है कि आपको बहुत कम बार अस्वीकृति मिलेगी।
  2. एक्सपोनेंशियल बैकऑफ़ और ज़िटर के साथ पुनः प्रयास करें। 1 सेकंड रुकें, फिर 2, फिर 4, और एक यादृच्छिक अंश जोड़ें ताकि कई वर्कर एक साथ पुनः प्रयास न करें। कुछ प्रयासों के बाद रुक जाएँ।
  3. अंधाधुंध पुनः प्रयास न करें। एक खराब अनुरोध या खराब कुंजी हर बार विफल हो जाएगी। केवल रेट लिमिट और अस्थायी सर्वर त्रुटियों पर ही पुनः प्रयास करें।

आधिकारिक OpenAI Python SDK 429 और सर्वर त्रुटियों पर बैकऑफ़ के साथ रीट्राई करता है, और आप max_retries से इसे नियंत्रित करते हैं। सेमाफोर के साथ, एक बैच जॉब इस प्रकार दिखता है:

import asyncio
import os
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://api.abliteratedapi.com/v1",
    api_key=os.environ["ABLITERATED_API_KEY"],
    max_retries=5,
)
sem = asyncio.Semaphore(8)   # use 2 on a trial key

async def ask(prompt):
    async with sem:
        r = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main():
    prompts = [f"Give one short fact about the number {n}." for n in range(40)]
    answers = await asyncio.gather(*(ask(p) for p in prompts))
    print(len(answers), "answers")

asyncio.run(main())

चालीस प्रॉम्प्ट पास होते हैं, एक समय में आठ से ज़्यादा नहीं। यदि आप अपना क्लाइंट बना रहे हैं, तो उसमें ये दो विचार रखें: चल रहे कॉल्स पर एक सीमा, और बढ़ता हुआ रीट्राई डिले।

रेट लिमिट कॉन्टेक्स्ट विंडो नहीं है

लोग अक्सर दोनों को भ्रमित कर देते हैं, क्योंकि दोनों तब त्रुटियां देते हैं जब आप बहुत अधिक मांग करते हैं। एक रेट लिमिट यह नियंत्रित करता है कि आप कितने अनुरोध भेजते हैं। कॉन्टेक्स्ट विंडो यह नियंत्रित करती है कि एक अनुरोध कितना बड़ा हो सकता है।

इस API पर कॉन्टेक्स्ट विंडो 100,000 टोकन की है, जिसमें प्रॉम्प्ट और कम्पलीशन दोनों शामिल हैं। यदि आपका प्रॉम्प्ट 95,000 टोकन का है, तो जवाब के लिए अधिकतम 5,000 टोकन शेष रहते हैं। max_tokens पैरामीटर वैकल्पिक है: इसे छोड़ दें और कम्पलीशन विंडो में जो शेष है, उसे उपयोग कर सकता है। जब आप जानते हैं कि जवाब छोटा होना चाहिए, तो इसे सेट करना एक अच्छी आदत है, क्योंकि आउटपुट टोकन की कीमत 10 लाख पर $0.50 है, जबकि इनपुट की कीमत 10 लाख पर $0.15 है। एक पूर्ण 95,000-टोकन वाले प्रॉम्प्ट का इनपुट खर्च 95,000 x 0.15 / 1,000,000 = $0.01425 होता है।

रेट लिमिट कॉन्टेक्स्ट विंडो को छोटा नहीं करता, और बड़ा कॉन्टेक्स्ट अतिरिक्त रेट लिमिट का उपयोग नहीं करता। प्रत्येक कॉल एक अनुरोध है, चाहे उसका आकार कुछ भी हो, जब तक कि बॉडी 8 MB से कम रहे।

स्ट्रीमिंग और रेट लिमिट

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

सामान्य गलतियाँ

  • कोई वर्कर कैप नहीं। 50 वर्कर्स वाले थ्रेड पूल का उपयोग 8 की सीमा के साथ करने पर अधिकांश कॉल्स अस्वीकार कर दिए जाएंगे। कन्करेंसी लिमिट के अनुसार पूल को मिलाएं।
  • तुरंत रीट्राई। अस्वीकृति के तुरंत बाद रीट्राई करने से सबसे खराब समय पर लोड बढ़ता है। प्रतीक्षा करें, और हर बार पहले से अधिक समय तक प्रतीक्षा करें।
  • प्रत्येक त्रुटि को प्रति मिनट अनुरोध मानना। टाइमआउट, खराब कुंजी और ओवरसाइज्ड बॉडी के लिए अलग-अलग समाधान की आवश्यकता है। स्टेटस कोड और X-Request-Id हेडर लॉग करें।
  • सब कुछ के लिए एक ही कुंजी साझा करना। एक नाइटली बैच जॉब और एक लाइव चैट फीचर एक ही कुंजी पर 8 स्लॉट के लिए प्रतिस्पर्धा करते हैं। अलग-अलग कुंजियां उपयोग करें, या बैच को शांत घंटों के लिए शेड्यूल करें।
  • धीमी स्ट्रीम को अनदेखा करना। एक क्लाइंट जो पढ़ना बंद कर देता है लेकिन कनेक्शन खुला रखता है, वह अभी भी एक स्लॉट पकड़े रखता है।

अस्वीकृत कॉल के लिए अपने लॉग में एक काउंटर जोड़ें। यदि यह शून्य पर बना रहता है, तो आपकी कैप सही ढंग से सेट है। यदि यह बढ़ता है, तो पुनः प्रयास जोड़ने से पहले पूल का आकार कम करें।

सीमाओं के आसपास योजना बनाना

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

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

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

सर्वर अतिरिक्त अनुरोधों को अस्वीकार करता है, आमतौर पर HTTP 429 के साथ, और आपके कोड को प्रतीक्षा करके रीट्राई करना चाहिए। तब तक गति कम करें या कन्करेंसी कम करें जब तक त्रुटियां बंद न हो जाएं।

इस API पर सीमाएँ क्या हैं?

एक पूर्ण कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 अनुरोध की अनुमति देती है। एक ट्रायल कुंजी 2 समानांतर अनुरोध और प्रति मिनट 60 की अनुमति देती है।

क्या रेट लिमिट कॉन्टेक्स्ट विंडो के समान है?

नहीं। एक रेट लिमिट नियंत्रित करता है कि आप समय के साथ कितने अनुरोध भेज सकते हैं। कॉन्टेक्स्ट विंडो, यहाँ 100,000 टोकन, नियंत्रित करता है कि एक अनुरोध और उसका जवाब कितना बड़ा हो सकता है।

मैं प्रतिक्रिया से अपनी सीमाएँ कैसे देखूँ?

X-RateLimit-Limit-Requests और X-RateLimit-Limit-Concurrency प्रतिक्रिया हेडर्स पढ़ें। X-Balance-USD हेडर आपका शेष क्रेडिट दिखाता है, और X-Request-Id एक विशिष्ट कॉल की पहचान करता है।

क्या अस्वीकृत अनुरोधों का पैसा लगता है?

नहीं। इस API पर फेल या अस्वीकृत अनुरोधों पर चार्ज नहीं किया जाता है।

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

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

API कुंजी पाएँ