ขีดจำกัดอัตรา API คืออะไร? ขีดจำกัด การลองใหม่ บริบท
ขีดจำกัดอัตราจำกัดปริมาณการจราจรที่คีย์หนึ่งสามารถส่งไปยัง API ได้ในช่วงเวลาหนึ่ง หน้าเว็บนี้อธิบายว่าขีดจำกัดอัตรา API คืออะไรในทางปฏิบัติ วิธีการเขียนโค้ดเพื่อจัดการกับมัน และขีดจำกัดของ API นี้คืออะไร
อัปเดต

ประเด็นสำคัญ
- ขีดจำกัดอัตราจำกัดจำนวนคำขอต่อนาทีหรือจำนวนคำขอที่กำลังดำเนินการอยู่ ดังนั้นไคลเอนต์หนึ่งตัวจึงไม่สามารถทำให้บริการล้นได้
- ขีดจำกัดอัตราไม่เหมือนกับหน้าต่างบริบท: อย่างหนึ่งจำกัดปริมาณการจราจร อีกอย่างหนึ่งจำกัดขนาดของคำขอเดียว
- คีย์เต็ม: คำขอพร้อมกัน 8 รายการและ 300 รายการต่อนาที คีย์ทดลอง: คำขอพร้อมกัน 2 รายการและ 60 รายการต่อนาที
- จัดการขีดจำกัดด้วยข้อจำกัด concurrency การลองใหม่แบบ backoff และการดู response headers
ขีดจำกัดอัตราคืออะไร
แล้ว API Rate Limit คืออะไร? มันคือกฎที่บอกว่าบัญชีหรือคีย์หนึ่ง ๆ สามารถเรียกใช้ได้กี่ครั้งในช่วงเวลาหนึ่ง หรือสามารถรันพร้อมกันได้กี่ครั้ง หากเกินขีดจำกัด เซิร์ฟเวอร์จะปฏิเสธการเรียกเพิ่มเติมแทนที่จะให้บริการ API HTTP ส่วนใหญ่จะส่งสัญญาณด้วยรหัสสถานะ 429 (Too Many Requests) และหลายตัวเพิ่ม header ที่บอกเวลาที่จะลองใหม่ ตรวจสอบเอกสารของแต่ละบริการเพื่อดูพฤติกรรมที่แน่นอน
ขีดจำกัดมีอยู่เพราะเซิร์ฟเวอร์โมเดลมีกำลังประมวลผลจำกัด หากไม่มีขีดจำกัด สคริปต์หนึ่งในลูปที่แน่นอาจทำให้คนอื่นช้าลง สำหรับคุณในฐานะนักพัฒนา มันหมายถึงสองสิ่ง: โค้ดของคุณต้องคาดหวังการปฏิเสธและกู้คืนจากมัน และการออกแบบของคุณควรกระจายงานแทนที่จะยิงทั้งหมดพร้อมกัน
ขีดจำกัดสามประเภทที่คุณจะพบ
ผู้ให้บริการผสมและจับคู่ขีดจำกัดเหล่านี้ ดังนั้นอ่านดูว่าขีดจำกัดใดที่ใช้กับคีย์ของคุณ
| ประเภท | สิ่งที่นับ | ผลกระทบทั่วไป |
|---|---|---|
| คำขอต่อนาที | การเรียกที่เริ่มในนาทีที่เลื่อนไป | burstถูกปฏิเสธแม้ว่าการเรียกแต่ละครั้งจะเล็ก |
| คำขอพร้อมกัน | การเรียกที่กำลังดำเนินการอยู่ ณ เวลาเดียวกัน | worker แบบขนานที่เกินข้อจำกัดจะถูกปฏิเสธหรือเข้าคิว |
| โควตาโทเคนหรือค่าใช้จ่าย | โทเคนหรือเงินที่ใช้ต่อนาที วัน หรือเดือน | พรอมต์ขนาดใหญ่จะชนกับขีดจำกัดเร็วกว่าพรอมต์ขนาดเล็ก |
ความพร้อมกันสำคัญกว่าสำหรับโมเดลภาษาเมื่อเทียบกับ API ทั่วไป เพราะการสร้างผลลัพธ์หนึ่งครั้งอาจใช้เวลาหลายวินาที worker สิบตัวที่รอการตอบกลับที่ยาวนานจะยึดสิบช่องตลอดเวลา
ขีดจำกัดของ API นี้
API นี้จำกัดจำนวนคำขอต่อนาทีและ concurrency ต่อคีย์:
| ประเภทคีย์ | คำขอพร้อมกัน | คำขอต่อนาที |
|---|---|---|
| คีย์เต็ม (พร้อมเครดิต) | 8 | 300 |
| คีย์ทดลอง | 2 | 60 |
ตัวเลขอีกสองตัวที่ควรรู้คือ ขนาดสูงสุดของ request body คือ 8 MB และทุก response จะมาพร้อม headers ที่คุณอ่านได้: X-Request-Id เพื่อระบุ call เมื่อคุณขอความช่วยเหลือ 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 ดังนั้น SDK ของ OpenAI ใดๆ ก็ใช้งานได้ทันทีที่คุณเปลี่ยน base URL เป็น https://api.abliteratedapi.com/v1.
คุณจะชนกับขีดจำกัดใดกันแน่?
นำตัวเลขสองตัวนี้มาหาร คีย์เต็มรูปแบบสามารถรัน parallel requests ได้ 8 request พร้อมกัน และ 300 request ต่อนาที ซึ่งเฉลี่ยแล้วคือ 5 request ต่อวินาที หากต้องการให้ถึง 300 request ต่อนาทีโดยมีเพียง 8 request ที่กำลังทำงานอยู่ แต่ละ call จะต้องเสร็จสิ้นภายในเวลาเฉลี่ย 1.6 วินาที (8 x 60 / 300) เมื่อข้อความจากโมเดลภาษามีความยาวเกินกว่าไม่กี่ประโยค เวลาในการตอบมักนานกว่านั้น ดังนั้นบนคีย์เต็มรูปแบบ ขีดจำกัด concurrency มักจะเป็นตัวจำกัดก่อน
สมมติกรณีตัวอย่างที่ call เฉลี่ยใช้เวลา 10 วินาที สล็อต 8 สล็อตจะให้คุณได้ 8 x 60 / 10 = 48 requests ต่อนาที ซึ่งต่ำกว่า 300 มาก ตรรกะเดียวกันนี้ใช้กับคีย์ทดลอง: สล็อต 2 สล็อตและ 60 requests ต่อนาที หมายถึงต้องมีการ call ที่ใช้เวลาต่ำกว่า 2 วินาทีก่อนที่ขีดจำกัดรายนาทีจะเริ่มสำคัญ ค่าระยะเวลาเหล่านี้เป็นเพียงการสาธิต ไม่ใช่การวัดผล จงวัดเวลา call ของคุณเองแล้วแทนที่ด้วยตัวเลขจริง
คำแนะนำในทางปฏิบัติ: กำหนดขนาด worker pool ให้ตรงกับขีดจำกัด concurrency ไม่ใช่ขีดจำกัด request และให้ขีดจำกัดรายนาทีทำหน้าที่เป็นตาข่ายความปลอดภัย
วิธีจัดการขีดจำกัดในโค้ด
สามนิสัยนี้จะครอบคลุมเกือบทุกกรณี
- จำกัด parallelism ด้วยตนเอง การใช้ semaphore ที่มีขนาดเท่ากับขีดจำกัด concurrency ของคุณ จะทำให้คุณแทบไม่ถูกปฏิเสธเลย
- ทำ retry พร้อม exponential backoff และ jitter รอ 1 วินาที แล้ว 2 วินาที แล้ว 4 วินาที โดยเพิ่มเศษส่วนสุ่มเข้าไป เพื่อให้ worker หลายตัวไม่ทำ retry พร้อมกัน หยุดหลังจากลองทำซ้ำไม่กี่ครั้ง
- อย่าทำ retry แบบไม่ไตร่ตรอง request ที่ผิดรูปแบบหรือคีย์ที่ผิดจะล้มเหลวทุกครั้ง ทำ retry เฉพาะเมื่อเจอ rate limit และข้อผิดพลาดชั่วคราวของเซิร์ฟเวอร์เท่านั้น
SDK Python ของ OpenAI ทางการทำ retry เมื่อเจอ 429 และข้อผิดพลาดของเซิร์ฟเวอร์พร้อม backoff แล้ว และคุณสามารถควบคุมมันผ่าน max_retries เมื่อรวมกับ semaphore งาน batch จะดูเป็นแบบนี้:
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())
พรอมต์ 40 ตัวจะถูกส่งผ่าน โดยไม่เกินแปดครั้งในเวลาเดียวกัน หากคุณสร้างไคลเอนต์ของคุณเอง ให้ใส่แนวคิดทั้งสองนี้เข้าไป: ขีดจำกัดของ call ที่กำลังทำงานอยู่ และระยะเวลา retry ที่เพิ่มขึ้น
ขีดจำกัดอัตราไม่ใช่หน้าต่างบริบท
ผู้คนมักสับสนระหว่างสองสิ่งนี้ เพราะทั้งคู่ทำให้เกิด error เมื่อคุณส่ง request มากเกินไป rate limit ควบคุมจำนวน request ที่คุณทำ context window ควบคุมขนาดของ request เดียวที่สามารถทำได้
บน API นี้ context window คือ 100,000 tokens โดยนับรวม prompt และ completion หาก prompt ของคุณมี 95,000 tokens จะมีเหลือเพียง 5,000 tokens สำหรับการตอบกลับ พารามิเตอร์ max_tokens เป็นตัวเลือก: หากไม่ระบุ completion สามารถใช้พื้นที่ที่เหลือของ window ได้ การตั้งค่าพารามิเตอร์นี้ยังคงเป็นนิสัยที่ดีเมื่อคุณรู้ว่าคำตอบควรสั้น เพราะ output tokens มีราคา $0.50 ต่อ 1M เทียบกับ $0.15 ต่อ 1M สำหรับ input prompt ขนาด 95,000 tokens เต็มรูปแบบจะมีค่าใช้จ่ายสำหรับ input เท่ากับ 95,000 x 0.15 / 1,000,000 = $0.01425
rate limit ไม่ได้ทำให้ context window เล็กลง และ context ขนาดใหญ่ไม่ได้ใช้ rate limit เพิ่มขึ้น call แต่ละครั้งถือเป็นหนึ่ง request ไม่ว่าขนาดของมันจะเป็นเท่าใด ตราบใดที่ body ไม่เกิน 8 MB
Streaming และ rate limits
เมื่อใช้ stream: true การตอบกลับจะส่งกลับมาผ่าน server-sent events ทีละ token และข้อมูลการใช้งานจะมาถึงในท้ายที่สุด call ที่ stream อยู่ยังคงครอบครอง slot concurrency หนึ่ง slot จนกว่า stream จะเสร็จสิ้น ดังนั้นผู้อ่านที่ช้าซึ่งคงการเชื่อมต่อไว้จะครอบครอง slot นานกว่าที่คุณคาดไว้ ควรปิด stream ที่ไม่ต้องการแล้ว
ข้อผิดพลาดทั่วไป
- ไม่มี worker cap thread pool ที่มี worker 50 ตัวเมื่อเทียบกับขีดจำกัด 8 สล็อต จะทำให้ call ส่วนใหญ่ถูกปฏิเสธ ควรปรับขนาด pool ให้ตรงกับขีดจำกัด concurrency
- ทำ retry ทันที การทำ retry ทันทีหลังจากถูกปฏิเสธจะเพิ่มโหลดในช่วงเวลาที่แย่ที่สุด ควรรอ และรอให้นานขึ้นในแต่ละครั้ง
- ถือว่า error ทุกอย่างคือ rate limit timeout คีย์ที่ผิด และ body ที่ใหญ่เกินไป ต่างต้องการวิธีแก้ไขที่แตกต่างกัน จดบันทึก status code และ header
X-Request-Id - แชร์คีย์เดียวสำหรับทุกอย่าง งาน batch กลางคืนและฟีเจอร์แชทสดบนคีย์เดียวกันจะแข่งขันกันใช้ 8 สล็อตเดียวกัน ควรใช้คีย์แยกกัน หรือจัดตารางเวลาสำหรับงาน batch ในช่วงเวลาเงียบ
- เพิกเฉยต่อ stream ที่ช้า ไคลเอนต์ที่หยุดอ่านแต่ยังคงการเชื่อมต่อไว้ จะยังคงครอบครอง slot อยู่
เพิ่มตัวนับสำหรับ call ที่ถูกปฏิเสธลงใน logs ของคุณ หากมันยังคงเป็นศูนย์ แสดงว่า cap ของคุณตั้งค่าถูกต้อง หากมันเพิ่มขึ้น ให้ลดขนาด pool ก่อนที่จะเพิ่มการ retry
การวางแผนโดยคำนึงถึงขีดจำกัด
ขีดจำกัดอัตราและการใช้งบประมาณเชื่อมโยงกัน การใช้งาน 8 ช่องเต็มกำลังสามารถทำให้เครดิตหมดลงได้รวดเร็ว ดังนั้นควรตัดสินใจก่อนเริ่มงานว่าจะยอมใช้เครดิตไปเท่าไร ราคาเป็นแบบจ่ายตามการใช้งาน (pay as you go) พร้อมเครดิตที่ไม่หมดอายุ และไม่มีการเรียกเก็บเงินสำหรับคำขอที่ล้มเหลวหรือถูกปฏิเสธ อ่านหน้า ราคาเพื่อดูอัตราและโบนัสการเติมเงิน และหน้า เริ่มต้นใช้งานอย่างรวดเร็วเพื่อดูพารามิเตอร์ของคำขอ เพื่อทดสอบลอจิก retryอย่างปลอดภัย รับคีย์ API และใช้เครดิตทดลองใช้ซึ่งไม่ต้องใช้บัตรเครดิต เพียงจำไว้ว่าเครดิตนี้จะทำงานภายใต้ขีดจำกัดระดับทดลอง
คู่มือเพิ่มเติม
ถาม-ตอบ
เกิดอะไรขึ้นเมื่อฉันเกินคำขอต่อนาที?
เซิร์ฟเวอร์จะปฏิเสธคำขอส่วนเกิน โดยปกติด้วย HTTP 429 และโค้ดของคุณควรรอและลองใหม่ ลดความเร็วหรือลดจำนวนคำขอพร้อมกันลงจนกว่าข้อผิดพลาดจะหยุดลง
ขีดจำกัดของ API นี้คืออะไร?
คีย์แบบเต็มอนุญาตให้ทำคำขอพร้อมกันได้ 8 คำขอ และ 300 คำขอต่อนาที คีย์แบบทดลองอนุญาตให้ทำคำขอพร้อมกันได้ 2 คำขอ และ 60 คำขอต่อนาที
ขีดจำกัดอัตราเหมือนกับหน้าต่างบริบทหรือไม่?
ไม่ ขีดจำกัดอัตราควบคุมจำนวนคำขอที่คุณสามารถส่งได้ในช่วงเวลาหนึ่ง หน้าต่างบริบทซึ่งรองรับ 100,000 โทเคนในกรณีนี้ ควบคุมขนาดของคำขอหนึ่งๆ และการตอบกลับของมัน
ฉันดูขีดจำกัดของฉันจาก response ได้อย่างไร?
อ่าน response headers X-RateLimit-Limit-Requests และ X-RateLimit-Limit-Concurrency header X-Balance-USD แสดงเครดิตคงเหลือของคุณ และ X-Request-Id ใช้ระบุการเรียกเฉพาะเจาะจง
คำขอที่ถูกปฏิเสธมีค่าใช้จ่ายหรือไม่?
ไม่ คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่มีการเรียกเก็บเงินใน API นี้
คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว
สร้างบัญชี คัดลอกคีย์ และเปลี่ยน base URL นั่นคือการตั้งค่าทั้งหมด
รับคีย์ API