เอกสาร BazaarLink

ราคา

BazaarLink การใช้โมเดลราคาที่ส่วนเพิ่มเป็นศูนย์ (เหมือนกับราคาปลีกอย่างเป็นทางการของผู้ให้บริการแต่ละราย) ค่าธรรมเนียมแพลตฟอร์มจะถูกเรียกเก็บจากการเติมเงิน (เงินฝาก): ค่าธรรมเนียมการทำธุรกรรม 10% บวก 5% ไต้หวัน VAT บนช่อง TWD เรียกเก็บเงินเป็น USD พร้อมด้วยใบเสนอราคา TWD และใบแจ้งหนี้แบบอิเล็กทรอนิกส์ การเติมเงินแบบบริการตนเองแบบจ่ายตามการใช้งาน รัฐวิสาหกิจอาจจัดให้มีการเรียกเก็บเงินรายเดือน (Net-30, ต่อรองได้)

วิธีการทำงาน

• ปริมาณการใช้ (เดบิต): การโทร API แต่ละครั้งจะถูกเรียกเก็บเงินตามการใช้โทเค็นจริงตามราคาปลีก USD อย่างเป็นทางการของผู้ให้บริการ โดยหักออกจากยอดคงเหลือของคุณ — เพิ่มเป็นศูนย์ และไม่มีค่าธรรมเนียมเพิ่มเติมสำหรับการบริโภค
• การเติมเงิน (ฝากเงิน): TWD จะถูกแปลงเป็น USD ตามอัตราการขายแบบเรียลไทม์และเพิ่มไปยังยอดคงเหลือของคุณ ค่าธรรมเนียมการทำธุรกรรม 10% จะถูกเรียกเก็บจากการเติมเงิน
• • วิธีชำระเงินและค่าธรรมเนียมของแต่ละช่องทางจะแสดงในหน้าชำระเงินจริง
• • ช่องทาง TWD ที่มีสิทธิ์จะแสดงภาษีและเงื่อนไขใบกำกับอิเล็กทรอนิกส์ไต้หวันก่อนชำระเงิน
• • การโอนเงินผ่านธนาคาร: สำหรับการเติมเงินขนาดใหญ่หรือการเติมเงินระดับองค์กร โปรดติดต่อเราเพื่อจัดเตรียมการโอนเงินและออกใบแจ้งหนี้แบบกำหนดเอง
• ใบกำกับมีเฉพาะช่องทางที่เปิดให้ใช้และระบุว่ามีสิทธิ์ หรือเงื่อนไของค์กรที่ยืนยันแล้ว หากต้องใช้เลขภาษี ใบเสนอราคา หรือวางบิลรายเดือน โปรดติดต่อฝ่ายขายก่อนชำระเงิน

เกี่ยวกับอัตราแลกเปลี่ยน

การแปลงเงินตราต่างประเทศใช้อัตราเรียลไทม์ การเรียกเก็บเงินรายเดือนจะใช้อัตรา ณ เวลาที่เรียกเก็บเงิน (ใบแจ้งยอด) ในขณะที่การเติมเงินแบบเติมเงินจะแปลงเป็นอัตราการเติมเงิน อัตราและการประทับเวลาจะยังคงอยู่กับบันทึกการเรียกเก็บเงิน

การคุ้มครองค่าบริการเมื่อคำขอล้มเหลว

หากคำขอไปยัง upstream ล้มเหลวโดยไม่มีข้อมูล usage ที่นำไปคิดค่าบริการได้ BazaarLink จะคืนยอดที่สำรองไว้ทั้งหมดโดยอัตโนมัติ แม้ stream จะเริ่มแล้วก่อนเกิดข้อผิดพลาด คำขอครั้งนั้นยังมีค่าใช้จ่าย 0 ดอลลาร์สหรัฐ

0 output tokens ไม่ได้หมายความว่าฟรีเสมอไป

usage.cost คือจำนวน USD ที่เรียกเก็บสำหรับคำขอนี้ แม้ output tokens เป็น 0 ก็อาจมีค่า input tokens โปรดตรวจสอบ usage.cost หรือบันทึก Activity เพื่อดูยอดสุดท้าย

เริ่มต้นอย่างรวดเร็ว

สามวิธีในการเชื่อมต่อ

เริ่มต้นภายใน 5 นาที BazaarLink รองรับ OpenAI SDK อย่างเต็มรูปแบบ — เพียงเปลี่ยน

สำหรับคำขอที่ใช้เวลานานกว่า 100 วินาที แนะนำให้ใช้ stream:true คำขอแบบ non-streaming จะส่งสถานะ 200 ก่อนและเริ่มส่งช่องว่าง keepalive หลังจากประมาณ 12 วินาที (ค่าเริ่มต้น ซึ่งปรับได้ผ่านการตั้งค่า deployment) หากเกิดข้อผิดพลาดภายหลัง ระบบจะส่งกลับเป็น 200 + error JSON keepalive คือช่องว่างก่อน JSON body ซึ่ง JSON parser มาตรฐานจะละเว้น

Base URL

https://api.bazaarlink.ai/v1

api.bazaarlink.ai เป็นจุดเข้าใช้งานเฉพาะ API ซึ่งดีพลอยแยกจากเว็บไซต์ Base URL เดิม https://bazaarlink.ai/api/v1 ยังรองรับเต็มรูปแบบ — การเชื่อมต่อที่มีอยู่ไม่ต้องเปลี่ยน

ใช้ OpenAI SDK

BazaarLink รองรับ OpenAI SDK อย่างเต็มรูปแบบ เพียงเปลี่ยน base URL และคีย์ API — โค้ดอื่นทั้งหมดเหมือนเดิม

from openai import OpenAI

client = OpenAI(
    base_url="https://api.bazaarlink.ai/v1",
    api_key="sk-bl-YOUR_API_KEY",
)

completion = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[
        {"role": "user", "content": "What is the meaning of life?"}
    ],
)

print(completion.choices[0].message.content)

ใช้คีย์ของคุณเอง (BYOK)

เชื่อมต่อ API key upstream กับบัญชีส่วนตัวหรือองค์กร คำขอที่เข้าเงื่อนไขจะใช้คีย์ของคุณก่อน เมื่อ upstream เกิดข้อผิดพลาด คำขออาจลองใช้แหล่งอื่นที่พร้อมใช้งานได้ หากไม่มี คำขอจะได้รับข้อผิดพลาด จัดการคีย์ส่วนตัวที่หน้าคีย์ และคีย์องค์กรที่การตั้งค่าองค์กร ไปที่การตั้งค่า BYOK →

การกรองเนื้อหา

การป้องกันเนื้อหาแบบสองทางสำหรับทราฟฟิก API ของคุณ: คำขอที่ตรวจพบ prompt injection จะถูกบล็อก (400) และข้อมูลอ่อนไหวในคำขอหรือการตอบกลับ (คีย์ API หมายเลขบัตร เลขบัตรประชาชน ฯลฯ) จะถูกปิดบังโดยอัตโนมัติ กฎและรายการยกเว้นปรับแต่งได้ พร้อมสถิติการใช้งาน ไปที่การตั้งค่าตัวกรองเนื้อหา →

การค้นหาเว็บ (:online)

ค้นหาเว็บก่อนที่โมเดลจะตอบ และส่งผลการค้นหาให้โมเดลเป็นข้อมูลอ้างอิง เหมาะกับคำถามที่ต้องใช้ข้อมูลล่าสุด เช่น ข่าว ราคา นโยบาย หรือผลิตภัณฑ์ที่เพิ่งเปิดตัว

Endpoint ที่รองรับ

• POST /api/v1/chat/completions
• POST /api/v1/messages
• POST /api/v1/responses

รองรับทั้ง Streaming (stream: true) และ non-streaming

วิธีใช้

วิธีที่ 1: เติม :online ต่อท้ายชื่อโมเดล

curl https://bazaarlink.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-mini:online",
    "messages": [{ "role": "user", "content": "วันนี้มีข่าว AI อะไรในไต้หวันบ้าง?" }]
  }'

วิธีที่ 2: ใช้พารามิเตอร์ plugins

{
  "model": "gpt-5.4-mini",
  "messages": [{ "role": "user", "content": "..." }],
  "plugins": [{
    "id": "web",
    "max_results": 5,
    "query_source": "last_user",
    "country": "taiwan",
    "time_range": "week"
  }]
}

วิธีที่ 3: ใช้ web_search_options

{
  "model": "gpt-5.4-mini",
  "messages": [{ "role": "user", "content": "..." }],
  "web_search_options": { "search_context_size": "high", "query_source": "conversation" }
}

เลือกใช้วิธีใดวิธีหนึ่ง หรือใช้ร่วมกันได้

พารามิเตอร์การค้นหา

พารามิเตอร์ต่อไปนี้ใส่ไว้ในรายการ web ของ plugins หรือใน web_search_options ได้ หากทั้งสองจุดระบุค่าต่างกัน จะยึดค่าจาก plugins

ลำดับความสำคัญของความลึก: engine (สี่ค่าด้านบน) > mode > search_context_size > ค่าเริ่มต้น medium

รูปแบบพารามิเตอร์ของ plugins และ web_search_options เข้ากันได้กับ OpenRouter จึงใช้คำขอเดิมได้โดยตรง

รูปแบบเครื่องมือค้นหาที่เข้ากันได้กับ Vercel AI Gateway

tools ของ Chat Completions รับรูปแบบเครื่องมือค้นหาต่อไปนี้ด้วย โดยจะถือเป็นการค้นหาเว็บหนึ่งครั้ง ประมวลผลโดยการค้นหาเว็บของแพลตฟอร์มนี้ และใช้การคิดค่าบริการกับรูปแบบการอ้างอิงแบบเดียวกัน:

{
  "model": "gpt-5.4-mini",
  "messages": [{ "role": "user", "content": "..." }],
  "tools": [{
    "type": "vercel:perplexity_search",
    "config": { "query": "การส่งออกเซมิคอนดักเตอร์ไต้หวันปี 2026", "max_results": 5 }
  }]
}

• type ที่รับได้: vercel:perplexity_search, vercel:exa_search, vercel:parallel_search, vercel:tako_search ทุก type มีพฤติกรรมและค่าใช้จ่ายเหมือนกัน
• config.query ถือเป็น search_prompt; config.max_results (หรือ num_results), config.country และพารามิเตอร์ชื่อเดียวกันจะจับคู่กับด้านบน ส่วนฟิลด์ที่ไม่รู้จักจะถูกละเว้น
• เครื่องมือค้นหาเหล่านี้จะไม่ถูกส่งต่อให้โมเดล
• หากคำขอเดียวมีเครื่องมือค้นหาหลายรายการ จะใช้เฉพาะรายการแรก

รองรับเครื่องมือ `web_search_preview` ด้วย

เมื่อใส่ { "type": "web_search_preview" } ใน tools ของ Responses หรือ endpoint อื่น จะถือเป็นการค้นหาเว็บหนึ่งครั้งเช่นกัน โดยการค้นหาเว็บของแพลตฟอร์มนี้เป็นผู้ประมวลผล ใช้การคิดค่าบริการและรูปแบบการอ้างอิงเดียวกัน เครื่องมือนี้จะไม่ถูกส่งต่อให้โมเดล

เมื่อใช้หลายรูปแบบพร้อมกัน

สามารถใช้ :online, plugins, web_search_options และเครื่องมือค้นหา (รวม web_search_preview) พร้อมกันได้ แต่แต่ละคำขอจะค้นหาและคิดค่าบริการเพียงครั้งเดียว (ถ้าใช้ search_queries จะคิดตามจำนวนรายการ) ลำดับของคำค้นหาคือ search_queries > config.query ของเครื่องมือค้นหา > search_prompt > query_source พารามิเตอร์อื่นจะรวมตามลำดับด้านบน

จะคืนค่า 400 invalid_web_search_options เฉพาะเมื่อชนิดพารามิเตอร์ผิด เช่น ส่งตัวเลขให้ engine หรือ include_domains ไม่ใช่อาร์เรย์สตริง หรือส่งค่าอยู่นอกช่วงที่กำหนด

ระดับการค้นหา

หากไม่ระบุระดับ จะใช้ medium

แหล่งอ้างอิงในคำตอบ

แหล่งข้อมูลที่ค้นพบจะส่งกลับใน annotations โดยใช้รูปแบบ url_citation ที่เป็นมาตรฐานทั่วไป:

"annotations": [
  {
    "type": "url_citation",
    "url_citation": {
      "url": "https://example.com/article",
      "title": "ชื่อบทความ",
      "content": "เนื้อหาสรุปแหล่งข้อมูล…",
      "start_index": 0,
      "end_index": 0
    }
  }
]

• แหล่งอ้างอิงแต่ละแห่งจะมีรายการอ้างอิงหนึ่งรายการ
• หากโมเดลทำเครื่องหมายแหล่งที่มาในคำตอบ (เช่น [source-1]) start_index และ end_index จะระบุตำแหน่งในข้อความคำตอบ หากไม่มีเครื่องหมาย ทั้งสองค่าจะเป็น 0

ตำแหน่งตาม endpoint:

• Chat Completions: non-streaming อยู่ที่ choices[].message.annotations; streaming จะส่งบล็อกเพิ่มเติมที่มีเฉพาะ delta.annotations ก่อน [DONE]
• Responses: อยู่ใน annotations ของเนื้อหา output_text; streaming จะส่งพร้อม event เสร็จสิ้น เช่น response.output_text.done
• Messages: แนบอยู่กับบล็อกเนื้อหาข้อความใน annotations; streaming จะส่งใน event text_delta ก่อนจบ

การคิดค่าบริการ

• ค่าใช้จ่ายต่อคำขอ = ค่าโมเดล + ค่าค้นหาเว็บ
• การค้นหาเว็บ คิดค่าบริการต่อการค้นหา ตามราคาของแพลตฟอร์ม ความลึกขั้นสูง (high หรือกำหนดขั้นสูงด้วย engine/mode) มีราคาต่อหน่วยสูงกว่า
• โมเดลฟรีก็มีค่าค้นหาเว็บ แต่ตัวโมเดลยังฟรี
• แต่ละคำขอจะค้นหาหนึ่งครั้งเป็นค่าเริ่มต้น หากใช้ search_queries จำนวนครั้งเท่ากับจำนวนคำค้นหาและคิดค่าตามจำนวน แม้ backend เปลี่ยนเส้นทางแล้วลองใหม่ ก็จะไม่ค้นหาหรือคิดค่าซ้ำ
• กรณีต่อไปนี้ ไม่คิดค่าค้นหาเว็บ:
  • การค้นหาเองล้มเหลว (คืนค่า 503 ดูด้านล่าง)
  • รายการที่ล้มเหลวเมื่อใช้ search_queries (คิดเฉพาะรายการที่สำเร็จ)
  • ค้นหาสำเร็จ แต่โมเดลสร้างคำตอบสุดท้ายไม่สำเร็จ
• ค่าค้นหาจะรวมอยู่ในการกันยอดคงเหลือล่วงหน้า ยอดหักจริงจะแสดงใน usage.cost ของคำตอบและบันทึกบัญชี

ข้อผิดพลาดและข้อจำกัด

• การจำกัดอัตรา สิทธิ์โมเดล การตรวจเนื้อหา และการตรวจสอบคำขอทั่วไปจะเสร็จก่อนการค้นหา คำขอที่ถูกบล็อกด้วยการตรวจเหล่านี้จะไม่ค้นหา
• พารามิเตอร์และเครื่องมือค้นหา (:online suffix, รายการ web ใน plugins, web_search_options, เครื่องมือด้านบน และ web_search_preview) ประมวลผลโดยแพลตฟอร์มนี้เท่านั้นและไม่ส่งต่อให้โมเดล

ข้อมูลโซเชียล (:social)

เติม :social ท้ายชื่อโมเดลเมื่อคำถามเกี่ยวกับแพลตฟอร์มโซเชียล ก่อนที่โมเดลจะตอบ BazaarLink จะดึงโพสต์ โปรไฟล์ หรือความคิดเห็นที่ตรงกันจากแพลตฟอร์มนั้นมาเป็นข้อมูลอ้างอิง หากดึงข้อมูลจากแพลตฟอร์มไม่ทันเวลา คำขอจะสำรองไปใช้การค้นเว็บปกติ คุณจึงยังได้คำตอบเสมอ

ตัวอย่าง

curl https://bazaarlink.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  --max-time 60 \
  -d '{
    "model": "gpt-5.4-mini:social",
    "messages": [{ "role": "user", "content": "โพสต์ล่าสุดบน X เกี่ยวกับ GPT-6" }]
  }'

สิ่งที่ควรรู้

• เวลารอ: ข้อมูลโซเชียลถูกดึงแบบเรียลไทม์ ดังนั้นคำขอ :social อาจใช้เวลา 20 ถึง 40 วินาทีก่อนที่คำตอบจะเริ่มแสดง เมื่อครบ 40 วินาทีจะสำรองไปใช้การค้นเว็บ ควรตั้ง timeout ของไคลเอนต์ไม่ต่ำกว่า 60 วินาที ส่วน :online ยังเร็วเหมือนเดิมเพราะเป็นการค้นเว็บปกติ
• ราคา: คำค้นที่ตอบด้วยข้อมูลโซเชียลใช้โควตาค้นหาฟรีรายวันเดียวกับ :online (5 ครั้งต่อวันสำหรับบัญชีที่ไม่มียอดคงเหลือ และ 10 ครั้งสำหรับบัญชีที่มียอดคงเหลือหรือมีการสมัครสมาชิก รีเซ็ตเวลา 00:00 UTC) เมื่อเกินโควตา แต่ละคำค้นจะคิดค่าบริการตามตารางราคา Data API (ดู GET /v1/data/catalog) เพิ่มจากค่าโทเค็นของโมเดล คำค้นที่สำรองไปใช้การค้นเว็บจะคิดราคาเท่ากับ :online
• ขอบเขต: :social อ่านเพียงบางแพลตฟอร์มโซเชียล และรายการขึ้นอยู่กับการตั้งค่าที่เปิดใช้อยู่ รายการล่าสุดอยู่ที่ /solutions/data-api#social-suffix แพลตฟอร์มที่อยู่ในแค็ตตาล็อก Data API แต่ไม่อยู่ในรายการนั้นจะไม่ถูกอ่านโดย :social คำค้นเกี่ยวกับแพลตฟอร์มนั้นหรือที่ไม่ระบุแพลตฟอร์มจึงตอบด้วยการค้นเว็บ
• ความเข้ากันได้: ใช้ได้กับ POST /api/v1/chat/completions, /api/v1/messages และ /api/v1/responses ทั้งแบบ streaming และไม่ streaming พร้อมการอ้างอิงแหล่งที่มาแบบเดียวกับ :online ไม่สามารถใช้ :online และ :social พร้อมกันในชื่อโมเดลเดียวได้ (400 invalid_web_search_options)

ย้ายจาก OpenRouter

API ของ BazaarLink เข้ากันได้กับ OpenRouter — การเชื่อมต่อส่วนใหญ่เปลี่ยนแค่สองค่า: base URL เป็น https://api.bazaarlink.ai/v1 และคีย์ API เป็นคีย์ BazaarLink ที่ขึ้นต้นด้วย sk-bl-

1. ฐาน URL: https://openrouter.ai/api/v1 → https://api.bazaarlink.ai/v1
2. คีย์ API: sk-or-... → sk-bl-... (สร้างได้ที่ /keys)
3. Model ID: ใช้รูปแบบ provider/model เดียวกัน (เช่น anthropic/claude-sonnet-4.6) ดูแคตตาล็อกทั้งหมดที่ GET /v1/models
4. fallback ผ่าน models[], streaming, tool calling และ structured outputs ใช้รูปแบบคำขอเดียวกัน

  from openai import OpenAI

  client = OpenAI(
-     base_url="https://openrouter.ai/api/v1",
-     api_key="sk-or-...",
+     base_url="https://api.bazaarlink.ai/v1",
+     api_key="sk-bl-...",
  )

การยืนยันตัวตน

คำขอ API ทั้งหมดต้องมี Authorization header พร้อมคีย์ API ของคุณ

Authorization: Bearer sk-bl-YOUR_API_KEY

รับคีย์ API จาก แดชบอร์ด เก็บคีย์ให้ปลอดภัย — อย่าเปิดเผยในโค้ดฝั่งไคลเอนต์

Header เสริม

หลักการ

BazaarLink ออกแบบตามหลักการหลักสามข้อ:

1. อินเทอร์เฟซรวม

API เดียว SDK เดียว โมเดลหลายร้อยตัว สลับระหว่าง OpenAI, Anthropic, Google Gemini, Meta Llama และอื่นๆ โดยไม่ต้องเปลี่ยนโค้ด — เพียงเปลี่ยน model ID

2. การปรับราคาให้เหมาะสม

BazaarLink กำหนดเส้นทางไปยังผู้ให้บริการที่คุ้มค่าที่สุดสำหรับโมเดลที่คุณเลือกโดยอัตโนมัติ คุณจ่ายเฉพาะที่ใช้ เรียกเก็บเป็น USD พร้อมการออกใบกำกับภาษีเต็มรูปแบบ

3. การจัดการคำขอ

เมื่อแหล่ง upstream มีปัญหา คำขออาจลองใช้แหล่งอื่นที่พร้อมใช้งานได้ หากไม่มีแหล่งใดใช้ได้ คำขอจะได้รับข้อผิดพลาด

มัลติโมดัล

BazaarLink รองรับอินพุตหลายรูปแบบ — ส่งรูปภาพ เสียง และไฟล์ข้างข้อความไปยังโมเดลที่รองรับ เนื้อหาจะถูกส่งผ่านไปยังผู้ให้บริการอัปสตรีม

รูปแบบที่รองรับ

ตัวอย่าง:

# Image — URL or base64 data URI
curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"google/gemini-3.5-flash","messages":[{"role":"user","content":[
        {"type":"text","text":"What is in this?"},
        {"type":"image_url","image_url":{"url":"https://example.com/photo.jpg"}}
      ]}]}'

# File / PDF — base64 data URI only, no URL
curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"google/gemini-3.5-flash","messages":[{"role":"user","content":[
        {"type":"file","file":{"filename":"doc.pdf","file_data":"data:application/pdf;base64,JVBER..."}},
        {"type":"text","text":"Summarize this."}
      ]}]}'

# Audio — raw base64, no URL. "format" is required
curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"google/gemini-3.5-flash","messages":[{"role":"user","content":[
        {"type":"text","text":"Transcribe this."},
        {"type":"input_audio","input_audio":{"data":"UklGRi...","format":"wav"}}
      ]}]}'

# Video — URL (CDN) or base64 data URI
curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"google/gemini-3.5-flash","messages":[{"role":"user","content":[
        {"type":"text","text":"Describe this video."},
        {"type":"video_url","video_url":{"url":"https://example.com/clip.mp4"}}
      ]}]}'

กำลังส่งภาพ

ใช้รูปแบบอาร์เรย์เนื้อหาที่มีส่วน image_url รูปแบบที่รองรับ: PNG, JPEG, WebP และ GIF (รวมถึงภาพเคลื่อนไหว) คุณสามารถรวมรูปภาพหลายรูปไว้ในข้อความเดียว โดยแต่ละภาพเป็นส่วน image_url แยกกัน:

curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer sk-bl-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o",
    "messages": [{"role":"user","content":[
      {"type":"text","text":"What is in this image?"},
      {"type":"image_url","image_url":{"url":"https://example.com/photo.jpg","detail":"auto"}}
    ]}]
  }'

ขีดจำกัด

BazaarLink มีขีดจำกัดสองแบบที่แยกจากกัน: ขีดจำกัดอัตราสำหรับจำนวนคำขอต่อนาที และขีดจำกัดเครดิตสำหรับค่าใช้จ่ายของบัญชี หากเกินขีดจำกัดอัตราจะได้รับ HTTP 429 หากเครดิตหมดจะได้รับ HTTP 402

ขีดจำกัดอัตรา

Rate ขีดจำกัดต่อผู้ใช้ (ไม่ใช่ต่อคีย์) วัดเป็นคำขอต่อนาที (RPM) ไม่มีขีดจำกัดรายวัน ระดับจะถูกกำหนดโดยอัตโนมัติตามยอดเครดิตในบัญชีของคุณ

เมื่อเกินขีดจำกัดอัตรา คุณจะได้รับการตอบกลับ 429 พร้อมส่วนหัว Retry-After ใช้ Exponential Backoff เมื่อลองส่งคำขออีกครั้ง

ส่วนหัวการตอบสนอง

Response อาจมี x-request-id; x-generation-id สำหรับ response non-streaming; x-ratelimit-*; retry-after เมื่อเกี่ยวข้อง; และ x-auto-resolved-model สำหรับเส้นทาง auto หรือ auto:free

x-request-id: 85e6f35c71a31f19-SJC
x-generation-id: 85e6f35c71a31f19-SJC
x-ratelimit-limit: 200
x-ratelimit-remaining: 198
x-ratelimit-reset: 1740000060
retry-after: 5
x-auto-resolved-model: openai/gpt-4o

ขีดจำกัดเครดิต

การตอบกลับ 402 หมายความว่ายอดคงเหลือในบัญชีหรือเพดานการใช้จ่ายของคีย์ลดลงเหลือศูนย์ ไม่ใช่เพราะคุณส่งคำขอเร็วเกินไป การตอบกลับนี้จะไม่มี rate limit headers และหากถึงขีดจำกัดระหว่างการ stream คุณจะได้รับ SSE error event แทนการเปลี่ยนสถานะ HTTP

รายการอนุญาต IP

คุณสามารถตั้งค่ารายการอนุญาต IP แยกสำหรับคีย์ API แต่ละรายการ เพื่อให้เฉพาะคำขอจาก IP ต้นทางที่กำหนดเท่านั้นที่ใช้คีย์นั้นได้

เหมาะใช้เมื่อใด

เหมาะสำหรับการใช้งานบนเซิร์ฟเวอร์ production ที่มี IP ขาออกแบบคงที่ หากแอปส่งคำขอจากเครือข่ายบ้าน เครือข่ายมือถือ หรือที่อยู่ที่เปลี่ยนแปลงได้ โปรดตรวจสอบว่า IP ขาออกคงที่ก่อน มิฉะนั้นคุณอาจล็อกตัวเองออก

วิธีตั้งค่า

เปิด /keys จากนั้นเปิดเมนู "⋯" ของคีย์ที่ต้องการ เลือก "รายการอนุญาต IP" ใส่รายการ แล้วบันทึก

หรือใช้ PATCH /api/v1/keys/:id ด้วย session ที่เข้าสู่ระบบแล้วหรือ Management API key:

PATCH https://api.bazaarlink.ai/v1/keys/KEY_ID
Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY
Content-Type: application/json

{
  "allowedCidrs": [
    "203.0.113.7",
    "198.51.100.0/24"
  ]
}

# Clear the allowlist and return to unrestricted access
{"allowedCidrs": []}

รูปแบบรายการ

ใน UI ให้ใส่หนึ่งค่าต่อบรรทัด ส่วน API ให้ส่งค่าเดียวกันในอาร์เรย์ `allowedCidrs` รองรับ IPv4 แบบไม่ระบุ CIDR, IPv4 CIDR หรือ IPv6 literal (เทียบข้อความแบบตรงกันเท่านั้น)

203.0.113.7
198.51.100.0/24
2001:db8::1

การทำงาน

เว้นว่าง (ส่งอาร์เรย์ [] ที่ว่างเปล่า) หมายถึงไม่จำกัด IP ต้นทาง นี่คือค่าเริ่มต้น พฤติกรรมของคีย์ที่มีอยู่จึงไม่เปลี่ยนแปลง

ระบบอ่าน IP ต้นทางจาก header `cf-connecting-ip`

หากรายการไม่ว่างแต่ไม่สามารถระบุ IP ต้นทางได้ คำขอจะถูกปฏิเสธ (fail-closed)

เบรกฉุกเฉินส่วนตัว

วงเงินค่าใช้จ่าย USD คงที่ 1 นาทีและ 1 ชั่วโมง ที่ใช้กับ API Key ทั้งหมดของคุณ เมื่อถึงขีดจำกัดของช่วงเวลา คำขอใหม่จะได้รับ HTTP 429 และ window จะรีเซ็ตอัตโนมัติตามรอบเวลา

ความปลอดภัยของบัญชี

นอกจากรหัสผ่านแล้ว BazaarLink ยังรองรับการยืนยันสองขั้นตอนเพื่อเพิ่มการป้องกันตอนเข้าสู่ระบบอีกชั้นหนึ่ง

เปิดใช้การยืนยันสองขั้นตอน (TOTP)

1. ไปที่หน้า “ตั้งค่า” หาส่วน “การยืนยันสองขั้นตอน (TOTP)” แล้วคลิก “เปิดใช้การยืนยันสองขั้นตอน”
2. สแกน QR code บนหน้าจอด้วยแอป authenticator (เช่น Google Authenticator) หรือป้อน secret ที่แสดงด้านล่างด้วยตนเอง
3. ป้อนรหัส 6 หลักที่แอป authenticator สร้างขึ้นแล้วยืนยัน ก็จะเปิดใช้งานเสร็จสมบูรณ์

หลังเปิดใช้งาน ระบบจะแสดงรหัสสำรอง 8 ชุด (แสดงเพียงครั้งเดียว) — แต่ละชุดมี 10 ตัวอักษรและใช้ได้ครั้งเดียว กรุณาจดหรือคัดลอกเก็บไว้ในที่ปลอดภัยนอกเหนือจากโทรศัพท์ทันที ใช้รหัสสำรองเข้าสู่ระบบได้เมื่อทำโทรศัพท์หายหรือเข้าแอป authenticator ไม่ได้

วิธีอื่นในการปกป้องบัญชีของคุณ

ใช้ฟีเจอร์เหล่านี้ร่วมกับการยืนยันสองขั้นตอน เพื่อลดความเสียหายจากคีย์ที่รั่วไหลหรือถูกใช้ในทางที่ผิดได้มากขึ้น:

• รายการอนุญาต IP — จำกัดให้ใช้ API key ได้เฉพาะจาก IP ต้นทางที่กำหนดเท่านั้น
• เบรกฉุกเฉินส่วนตัว — กำหนดวงเงินค่าใช้จ่ายต่อนาทีและต่อชั่วโมง ซึ่งจะหยุดโดยอัตโนมัติเมื่อเกินกำหนด
• วงเงินค่าใช้จ่ายต่อคีย์ — กำหนดวงเงินค่าใช้จ่ายรายวัน รายสัปดาห์ หรือรายเดือน เมื่อสร้างหรืออัปเดต API key

การสร้างภาพ

สร้างภาพผ่าน /v1/chat/completions ด้วย modalities:["image"] หรือ /v1/images/generations ที่เข้ากันได้กับ OpenAI DALL·E

curl -N https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"openai/gpt-5.4-image-2","messages":[{"role":"user","content":"a red cat on a sofa"}],"modalities":["image","text"],"stream":true}'

โฟลว์แบบเต็ม (สตรีมมิ่ง, แก้ไขภาพ, โปรโตคอล SSE, รายการโมเดล) ดูที่ API Reference →

การสร้างวิดีโอ

โฟลว์ 3 ขั้นตอนแบบ async (submit → poll → content) การสร้างวิดีโอใช้เวลา 30 วินาทีถึง 5 นาที

curl https://api.bazaarlink.ai/v1/videos \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"bytedance/seedance-2.0","prompt":"a bird flying over mountains","duration":3}'
# → 202 { "id": "vjob_xxx", "status": "pending" }

โฟลว์แบบเต็ม (polling, ดาวน์โหลด, ประเภทงาน, ข้อควรระวัง) ดูที่ API Reference →

PDF อินพุต

ส่งเอกสาร PDF โดยตรงในข้อความไปยังโมเดลที่รองรับ PDF แบบเนทีฟ (เช่น Claude, Gemini) BazaarLink จะส่งไฟล์ตรงไปยังโมเดล — คิดเป็น input tokens ปกติ ไม่มีค่าใช้จ่ายหรือขั้นตอนประมวลผลเพิ่มเติม

รูปแบบที่รองรับ

• PDF เอกสาร (ข้อความ รูปภาพ ตาราง สแกนแล้ว) ข้อมูลที่เข้ารหัส
• Base64 URL (`data:application/pdf;base64,...`)
• เอกสารหลายหน้า
• เฉพาะ PDF ที่ไม่มีรหัสผ่าน

import base64

with open("document.pdf", "rb") as f:
    pdf_data = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="anthropic/claude-sonnet-4.6",
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "file",
                "file": {
                    "filename": "document.pdf",
                    "file_data": f"data:application/pdf;base64,{pdf_data}",
                },
            },
            {"type": "text", "text": "Summarize this document."},
        ],
    }],
)

อินพุตวิดีโอ

ส่งไฟล์วิดีโอไปยังโมเดลที่รองรับอินพุตวิดีโอเพื่อวิเคราะห์ สร้างคำบรรยาย หรือตอบคำถามเกี่ยวกับฉากและเหตุการณ์ ใช้ได้ทั้ง URL โดยตรงหรือ base64 data URI — URL มีประสิทธิภาพกว่าสำหรับวิดีโอที่เข้าถึงได้สาธารณะ ส่วน base64 ใช้สำหรับไฟล์ในเครื่องหรือวิดีโอส่วนตัว

รูปแบบที่รองรับ

response = client.chat.completions.create(
    model="google/gemini-3.5-flash",
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "video_url",
                "video_url": {"url": "https://example.com/video.mp4"},
            },
            {"type": "text", "text": "What is happening in this video?"},
        ],
    }],
)

เอกสารอ้างอิง API ฉบับเต็ม →

OAuth PKCE

OAuth 2.0 PKCE (Proof Key for Code Exchange) ช่วยให้แอปไคลเอ็นต์สาธารณะ (SP ของเบราว์เซอร์ แอปบนอุปกรณ์เคลื่อนที่) ทำการโทร API ในนามของผู้ใช้แต่ละรายโดยไม่ต้องจัดเก็บเซิร์ฟเวอร์ลับฝั่งไคลเอ็นต์ที่มีอายุยาวนาน

เมื่อใดควรใช้ OAuth PKCE

• การสร้างเบราว์เซอร์ SPA หรือแอปมือถือที่ต้องการการเรียกเก็บเงินต่อผู้ใช้
• SaaS ผู้เช่าหลายราย — ผู้ใช้แต่ละรายชำระค่าใช้งาน API ของตนเอง
• You ไม่สามารถจัดเก็บฝั่งไคลเอ็นต์ลับที่แบ่งใช้ (ไคลเอ็นต์สาธารณะ)
• คุณต้องการคีย์แยกต่างหากที่เพิกถอนได้สำหรับผู้ใช้แต่ละราย (ใช้ได้จนกว่าผู้ใช้จะเพิกถอน) แทนที่จะใช้คีย์ API ร่วมกันเพียงคีย์เดียว

สิ่งที่ผู้ใช้ของคุณจะเห็น

อธิบายขั้นตอนเหล่านี้บนหน้าจอลงชื่อเข้าใช้ของคุณเอง:

1. ในแอปของคุณ ผู้ใช้เลือก "ลงชื่อเข้าใช้ด้วย BazaarLink" (หรือชื่อปุ่มอื่นที่คุณตั้ง)
2. เบราว์เซอร์เปิดหน้าอนุญาตของ BazaarLink หากยังไม่ได้ลงชื่อเข้าใช้ ผู้ใช้จะลงชื่อเข้าใช้ก่อนแล้วกลับมาที่หน้านี้โดยอัตโนมัติ
3. หน้าจะแสดงที่อยู่แอปของคุณและสิ่งที่จะเกิดขึ้นหากอนุญาต: ระบบสร้างคีย์ API ใหม่สำหรับแอป การใช้งานถูกเรียกเก็บจากยอดคงเหลือ BazaarLink ของผู้ใช้ และผู้ใช้เพิกถอนคีย์ได้ทุกเมื่อ ผู้ใช้ตั้งชื่อคีย์และกำหนดวงเงินใช้จ่ายรายเดือนได้ (ไม่บังคับทั้งสองอย่าง)
4. ผู้ใช้คลิก “อนุญาต” แล้วถูกส่งกลับไปที่แอปของคุณ หากคลิก “ปฏิเสธ” ระบบจะไม่สร้างคีย์ แอปของคุณจะไม่ได้รับแจ้ง และผู้ใช้จะเห็นหน้า “ปฏิเสธการเข้าถึงแล้ว”
5. หากต้องการเพิกถอนการเข้าถึงภายหลัง ผู้ใช้เปิดหน้า “คีย์ API” (https://bazaarlink.ai/keys) แล้วปิดใช้งานหรือลบคีย์ที่ตั้งชื่อตามแอปของคุณ

วิธีการทำงาน

ขั้นตอนที่ 1 — เริ่มต้นการตรวจสอบสิทธิ์ — สร้าง code_verifier แบบสุ่ม (สตริงสุ่มแบบยาว) และแฮช SHA-256 เป็น code_challenge จากนั้นเปลี่ยนเส้นทางผู้ใช้ไปยังหน้าการรับรองความถูกต้อง BazaarLink

https://bazaarlink.ai/auth?callback_url=https://yourapp.com/callback&code_challenge=CODE_CHALLENGE&code_challenge_method=S256

พารามิเตอร์ของ URL การอนุญาต

• callback_url (จำเป็น) — ที่ที่ผู้ใช้จะกลับมาหลังอนุญาต ดูกฎด้านล่าง
• code_challenge (จำเป็น) — SHA-256 ของ code_verifier ที่เข้ารหัสแบบ base64url (43 อักขระ ไม่มี padding)
• code_challenge_method (จำเป็น) — ต้องเป็น S256
• state (ไม่บังคับ) — ค่า CSRF แบบทึบแสงของคุณเอง ความยาว 1 ถึง 256 อักขระ ASCII ที่พิมพ์ได้ BazaarLink จะส่งคืนตามเดิมเป็น &state=… ต่อท้าย code ทันที หาก state มีรูปแบบไม่ถูกต้อง หน้าอนุญาตจะแสดง "คำขออนุญาตไม่ถูกต้อง"
• key_label (ไม่บังคับ) — ไม่เกิน 100 อักขระ ใช้กรอกชื่อคีย์ในหน้าขอความยินยอมไว้ล่วงหน้า (ผู้ใช้ยังแก้ไขได้) ป้ายชื่อที่ยาวเกินไปหรือว่างเปล่าจะถูกละเว้น
• Headless tools (CLI / desktop, no callback_url) — omit callback_url. After the user allows, the page shows a one-time code (valid 5 minutes, single use) for them to enter into your tool; exchange it exactly like a redirected code. The page cannot show which app is asking, so tell users to enter the code only in a tool they started themselves.

ไม่รองรับ

• workspace_id และ required_workspace_id — ไม่รองรับ คีย์เป็นของบัญชีผู้ใช้เองเสมอ
• code_challenge_method=plain — ไม่รองรับ (เฉพาะ S256)

กฎของ callback_url

• ต้องเป็น https:// ส่วน http:// รับเฉพาะ localhost, 127.0.0.1 และ [::1] (พอร์ตใดก็ได้) โดยหน้าขอความยินยอมจะแสดงคำเตือนการพัฒนาในเครื่อง
• ห้ามมี fragment (#) ห้ามมีชื่อผู้ใช้หรือรหัสผ่านใน URL และยาวไม่เกิน 2048 อักขระ
• หน้าขอความยินยอมจะแสดงชื่อโฮสต์ callback ของคุณ เพื่อให้ผู้ใช้เห็นว่าแอปใดเป็นผู้ขอ
• หลังผู้ใช้อนุญาต เบราว์เซอร์จะถูกส่งไปยัง callback_url ของคุณพร้อมต่อท้าย code=… (และ state=… หากคุณส่งมา โดยสตริงคิวรีเดิมจะถูกคงไว้) code ใช้ได้ 10 นาทีและใช้ได้เพียงครั้งเดียว

ขั้นตอนที่ 2 — แลกรหัสสำหรับคีย์ API — หลังจากที่ผู้ใช้อนุญาตคำขอแล้ว BazaarLink จะเปลี่ยนเส้นทางไปยัง callback_url ของคุณพร้อม code แบบใช้ครั้งเดียว code ใช้ได้ 10 นาทีและใช้ได้เพียงครั้งเดียว หาก code_verifier ผิด code จะถูกทำลาย POST code, code_verifier และ code_challenge_method (ต้องมีทั้งสามค่า) เพื่อรับคีย์ API ของผู้ใช้

curl https://bazaarlink.ai/api/v1/auth/keys \
  -H "Content-Type: application/json" \
  -d '{
    "code": "<CODE_FROM_CALLBACK_URL>",
    "code_verifier": "<CODE_VERIFIER>",
    "code_challenge_method": "S256"
  }'

# Response
# { "key": "sk-bl-...", "user_id": "..." }

ขั้นตอนที่ 3 — ใช้คีย์กำหนดขอบเขตผู้ใช้ — คีย์ที่ส่งคืนคือคีย์ BazaarLink API ปกติที่เป็นของผู้ใช้ที่อนุญาต — การใช้งานจะถูกเรียกเก็บจากยอดคงเหลือของผู้ใช้รายนั้น ไม่ใช่ของคุณ

curl https://bazaarlink.ai/api/v1/chat/completions \
  -H "Authorization: Bearer sk-bl-..." \
  -H "Content-Type: application/json" \
  -d '{"model": "google/gemini-3.5-flash", "messages": [{"role": "user", "content": "Hello"}]}'

ตัวอย่าง JavaScript (เบราว์เซอร์)

// 1) Create a verifier + S256 challenge, then send the user to BazaarLink
const b64url = (buf) => btoa(String.fromCharCode(...new Uint8Array(buf)))
  .replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
const verifier = b64url(crypto.getRandomValues(new Uint8Array(32)));
const challenge = b64url(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)));
sessionStorage.setItem("bl_verifier", verifier);
// "state" is optional: BazaarLink hands it back unchanged next to the code.
const state = b64url(crypto.getRandomValues(new Uint8Array(16)));
sessionStorage.setItem("bl_state", state);
location.href =
  "https://bazaarlink.ai/auth?callback_url=" + encodeURIComponent(location.origin + "/callback") +
  "&code_challenge=" + challenge + "&code_challenge_method=S256&state=" + state;

// 2) On /callback: check your own state, then exchange the one-time code for a user key
const params = new URLSearchParams(location.search);
if (params.get("state") !== sessionStorage.getItem("bl_state")) throw new Error("state mismatch");
const res = await fetch("https://bazaarlink.ai/api/v1/auth/keys", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    code: params.get("code"),
    code_verifier: sessionStorage.getItem("bl_verifier"),
    code_challenge_method: "S256",
  }),
});
if (!res.ok) throw new Error((await res.json()).error?.message ?? "exchange failed"); // 403 invalid_code: ask the user to authorize again
const { key } = await res.json(); // use as: Authorization: Bearer <key>

หน้า /auth และ POST /api/v1/auth/keys ให้บริการจาก https://bazaarlink.ai (ไม่ใช่ api.bazaarlink.ai) คีย์ที่คุณได้รับใช้ได้กับ base URL ทั้งสอง: https://bazaarlink.ai/api/v1 และ https://api.bazaarlink.ai/v1

หากผู้ใช้ตั้งวงเงินใช้จ่ายตอนอนุญาต วงเงินนั้นเป็นวงเงินรายเดือนและจะรีเซ็ตตามรอบเดือนของบัญชี

ข้อผิดพลาด

ข้อผิดพลาดใช้รูปแบบแบบ OpenAI {"error":{"message","type","code"}} POST /api/v1/auth/keys อาจส่งคืน:

• 400 invalid_code_challenge_method — ไม่มี code_challenge_method เป็น plain หรือเป็นค่าอื่นที่ไม่ใช่ S256
• 400 — JSON body ไม่ถูกต้อง หรือไม่มี code / code_verifier
• 403 invalid_code — ไม่รู้จัก code, code หมดอายุหรือถูกใช้แล้ว, code_verifier ผิด หรือบัญชีไม่ได้รับอนุญาตอีกต่อไป ทุกกรณีนี้ตั้งใจส่งข้อความเดียวกัน เพื่อไม่ให้ผู้เรียกแยกแยะได้ code_verifier ที่ผิดจะทำให้ code ถูกทำลายด้วย: ให้ผู้ใช้อนุญาตใหม่อีกครั้ง
• 429 rate_limited — พยายามแลกเปลี่ยนเกิน 30 ครั้งใน 10 นาทีจาก IP เดียว (ดูเฮดเดอร์ Retry-After)
• 429 key_total_cap — บัญชีมีคีย์ API ครบจำนวนสูงสุด 200 คีย์แล้ว
• 405 — รับเฉพาะ POST

สร้างโค้ดจากเซิร์ฟเวอร์ของคุณ (คีย์การจัดการ)

เจ้าของคีย์การจัดการ (Management Key) ส่วนบุคคลสามารถสร้างโค้ดการอนุญาตได้โดยตรงด้วย POST /api/v1/auth/keys/code โดยไม่ต้องพาผู้ใช้ผ่านหน้าเบราว์เซอร์ (เข้ากันได้กับ OpenRouter) โค้ดจะผูกกับเจ้าของคีย์การจัดการ ดังนั้นคีย์ที่แลกได้จึงเป็นคีย์มาตรฐานในบัญชีของเจ้าของรายนั้น โดยวงเงิน รอบเวลา วันหมดอายุ และชื่อจะเป็นไปตามที่กำหนดไว้ที่นี่ ใช้เมื่อเครื่องมือของคุณเองมีคีย์การจัดการอยู่แล้วและต้องการมอบคีย์ที่จำกัดสิทธิ์ให้แอป ขั้นตอนการแลก (POST /api/v1/auth/keys) เหมือนด้านบน

• callback_url (จำเป็น) และ code_challenge + code_challenge_method=S256 (จำเป็น) — กฎเดียวกับ URL การอนุญาต
• key_label (ไม่บังคับ) — ยาวได้ไม่เกิน 100 ตัวอักษร เป็นชื่อของคีย์ ค่าเริ่มต้น: "App: <โฮสต์ callback ของคุณ>"
• limit (ไม่บังคับ) — วงเงินการใช้จ่ายเป็น USD ตั้งแต่ 0 ขึ้นไป ถ้าเป็น 0 หรือไม่ระบุ หมายถึงไม่จำกัด
• usage_limit_type (ไม่บังคับ) — daily, weekly หรือ monthly: วงเงินรีเซ็ตบ่อยแค่ไหน ใช้ร่วมกับ limit เท่านั้น ค่าเริ่มต้นคือ monthly
• expires_at (ไม่บังคับ) — เวลาที่คีย์หมดอายุ: เวลา ISO 8601 UTC ในอนาคตที่มีวินาที เช่น 2026-12-31T23:59:59Z ค่าที่ละเอียดแค่ระดับนาทีจะถูกปฏิเสธ หากไม่ระบุ คีย์จะยังใช้งานได้จนกว่าจะถูกเพิกถอน
• workspace_id — ไม่รองรับ (400) spawn_agent และ spawn_cloud จะถูกรับแต่ไม่นำมาใช้

curl https://bazaarlink.ai/api/v1/auth/keys/code \
  -H "Authorization: Bearer sk-bl-YOUR_MGMT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "callback_url": "https://yourapp.com/callback",
    "code_challenge": "<CODE_CHALLENGE>",
    "code_challenge_method": "S256",
    "key_label": "My app",
    "limit": 10,
    "usage_limit_type": "monthly",
    "expires_at": "2026-12-31T23:59:59Z"
  }'

# Response
# { "data": { "id": "<ONE_TIME_CODE>", "app_id": 123456789, "created_at": "2026-10-22T12:00:00.000Z" } }
# Then POST { "code": "<ONE_TIME_CODE>", "code_verifier": "<CODE_VERIFIER>", "code_challenge_method": "S256" } to /api/v1/auth/keys

การตอบกลับ: { "data": { "id", "app_id", "created_at" } } id คือโค้ดใช้ครั้งเดียวสำหรับนำไปแลก (ใช้ได้ 10 นาที และใช้ได้ครั้งเดียว) BazaarLink ไม่มีระบบลงทะเบียนแอป ดังนั้น app_id จึงเป็นจำนวนเต็มคงที่ที่คำนวณจากที่อยู่ callback ของคุณ: ที่อยู่เดิมจะได้ app_id เดิมเสมอ

• 401 unauthorized — ไม่มีคีย์ Bearer หรือไม่รู้จักคีย์นั้น
• 403 management_key_required — คีย์ไม่ใช่คีย์การจัดการส่วนบุคคล (คีย์มาตรฐานและคีย์การจัดการขององค์กรจะถูกปฏิเสธ)
• 403 account_not_allowed — เจ้าของคีย์ถูกระงับหรือถูกลบ
• 400 — invalid_callback_url, invalid_code_challenge_method, invalid_code_challenge, invalid_expires_at, workspace_not_supported หรือเนื้อหาคำขอผิดรูปแบบ
• 429 rate_limited — สร้างโค้ดเกิน 30 ครั้งต่อชั่วโมงสำหรับเจ้าของรายเดียว หรือเกิน 120 ครั้งต่อชั่วโมงจาก IP เดียว (ดู Retry-After)

คีย์ที่คุณจะได้รับ

• คีย์ BazaarLink API มาตรฐาน (sk-bl-…) ชนิดเดียวกับคีย์ที่สร้างในหน้า “คีย์ API” และใช้ได้จนกว่าผู้ใช้จะเพิกถอน
• การใช้งานถูกเรียกเก็บจากยอดคงเหลือ BazaarLink ของผู้ใช้ หากผู้ใช้ตั้งวงเงินใช้จ่ายในหน้าขอความยินยอม วงเงินนั้นเป็นวงเงินรายเดือน
• ใช้ได้กับ base URL ทั้งสอง: https://bazaarlink.ai/api/v1 และ https://api.bazaarlink.ai/v1
• นับรวมในขีดจำกัด 200 คีย์ของบัญชี และแสดงในรายการ “คีย์ API” ของผู้ใช้ ซึ่งผู้ใช้ปิดใช้งานหรือลบได้ทุกเมื่อ
• บัญชีที่ถูกระงับหรือถูกลบไม่สามารถอนุญาตแอปได้ และ code ที่ออกก่อนการระงับจะถูกปฏิเสธเมื่อแลกเปลี่ยน (403 invalid_code)

สิ่งที่คุณจะได้รับ

• Authorization Code + PKCE flow สำหรับแอปพลิเคชันไคลเอ็นต์สาธารณะ
• การเรียกเก็บเงินต่อผู้ใช้: ผู้ใช้แต่ละรายจ่ายค่าใช้งานของตนเองจากยอดคงเหลือของตนเอง
• คีย์แยกต่างหากสำหรับผู้ใช้แต่ละราย แสดงในหน้า “คีย์ API” ของผู้ใช้ ซึ่งผู้ใช้เพิกถอนได้

การจัดการคีย์ API

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

การสร้างคีย์การจัดการ

ไปที่Management API หน้าคีย์แล้วคลิก "สร้าง" — เป็นหน้าแยกต่างหากจากคีย์ API มาตรฐานของคุณ ไม่ใช่ตัวเลือกประเภทในหน้าเดียวกัน

List คีย์

GET https://api.bazaarlink.ai/v1/keys
Authorization: Bearer sk-bl-YOUR_MGMT_KEY

# Response
{
  "keys": [
    {
      "id": "clxyz123...",
      "name": "Production Key",
      "keyType": "standard",
      "keyPrefix": "sk-bl-abc1",
      "keySuffix": "XyZ9",
      "enabled": true,
      "spendLimitUsd": 10.00,
      "spendLimitPeriod": "month",
      "expiresAt": null,
      "createdAt": "2026-01-01T00:00:00.000Z",
      "lastUsed": "2026-03-01T12:34:56.000Z",
      "requestCount": 1234,
      "totalTokens": 5678901
    }
  ]
}

สร้างคีย์ย่อย

POST https://api.bazaarlink.ai/v1/keys
Authorization: Bearer sk-bl-YOUR_MGMT_KEY
Content-Type: application/json

{
  "name": "Agent Key",
  "limit": 10.00,
  "limit_reset": "monthly",
  "expires_at": "2026-12-31T23:59:59Z"
}

# limit_reset: daily | weekly | monthly
# expires_at:  ISO 8601 datetime (optional)

# Response — save the key value, it won't be shown again
{
  "id": "clxyz789...",
  "name": "Agent Key",
  "key": "sk-bl-xyz789abcdef...",
  "keyType": "standard",
  "spendLimitUsd": 10.00,
  "spendLimitPeriod": "month",
  "expiresAt": "2026-12-31T23:59:59.000Z",
  "enabled": true,
  "createdAt": "2026-03-01T00:00:00.000Z"
}

Update Key

PATCH https://api.bazaarlink.ai/v1/keys/:id
Authorization: Bearer sk-bl-YOUR_MGMT_KEY
Content-Type: application/json

{"enabled": false}              # disable key
{"spendLimitUsd": 5, "spendLimitPeriod": "week"}  # set spend limit
{"spendLimitUsd": null}         # remove spend limit
# Response: {"updated": true}

เพิกถอนคีย์

DELETE https://api.bazaarlink.ai/v1/keys/:id
Authorization: Bearer sk-bl-YOUR_MGMT_KEY

# Returns 204 No Content on success

Query ยอดคงเหลือ

GET https://api.bazaarlink.ai/v1/credits
Authorization: Bearer sk-bl-YOUR_MGMT_KEY

# Response
{
  "data": {
    "total_credits": 12.345,
    "total_usage": 3.210
  }
}

การใช้งานแบบสอบถาม

GET https://api.bazaarlink.ai/v1/usage?period=month
Authorization: Bearer sk-bl-YOUR_MGMT_KEY

# period: day | week | month | year

การระบุแหล่งที่มาของแอป

ระบุแอปพลิเคชันของคุณในส่วนหัวของคำขอเพื่อเปิดใช้งานการติดตามการใช้งาน การเปิดเผยแดชบอร์ด และการวิเคราะห์แบบละเอียด

ส่วนหัวที่มีอยู่

from openai import OpenAI

client = OpenAI(
    base_url="https://api.bazaarlink.ai/v1",
    api_key="sk-bl-YOUR_KEY",
    default_headers={
        "HTTP-Referer": "https://yourapp.com",  # Optional: your site URL
        "X-Title": "My Application",             # Optional: your app name
    },
)

response = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}],
)

รหัสข้อผิดพลาด

Error รูปแบบการตอบสนอง

รูปแบบ error envelope แตกต่างตาม endpoint ใช้ HTTP status และ error.type เมื่อมี error.code อาจเป็น string หรือ numeric status และอาจไม่มี; error.message ใช้แสดงผลเท่านั้น

{
  "error": {
    "message": "Insufficient credits. Please top up to continue.",
    "type": "invalid_request_error",
    "code": "insufficient_credits"
  }
}

HTTP สถานะและข้อผิดพลาดรหัส

รูปแบบ error envelope แตกต่างตาม endpoint ใช้ HTTP status และ error.type เมื่อมี error.code อาจเป็น string หรือ numeric status และอาจไม่มี; error.message ใช้แสดงผลเท่านั้น

รหัสการเรียกเก็บเงินที่เครื่องอ่านได้

A 402 can represent different controls. Use these stable codes to choose the correct action.

Stable error.code catalog

These string codes are emitted by public inference and media paths. Branch on the string code when present; the HTTP status remains the broad failure class.

การตรวจสอบเนื้อหา

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

หมวดหมู่เนื้อหาที่จะถูกบล็อก

การตรวจสอบเป็นไปตามนโยบายการใช้งานที่ยอมรับได้ (Acceptable Use Policy) ของเรา และจะบล็อกเนื้อหาในหมวดหมู่ต่อไปนี้เป็นหลัก:

• เนื้อหาการแสวงหาประโยชน์ทางเพศ
• การขู่ใช้ความรุนแรง
• คำแนะนำในการดำเนินการที่ผิดกฎหมาย
• เนื้อหาที่เกี่ยวข้องกับอันตรายทางชีวภาพ

รูปแบบการตอบกลับ 403

คำขอที่ถูกบล็อกโดยการตรวจสอบจะได้รับข้อผิดพลาดในรูปแบบนี้:

{
  "error": {
    "message": "Your prompt was blocked by content moderation.",
    "type": "invalid_request_error",
    "code": "content_filter"
  }
}

คำขอที่ถูกบล็อกจะไม่ถูกเรียกเก็บเงิน — คุณจะไม่ถูกเรียกเก็บเงินสำหรับคำขอที่ถูกปฏิเสธ

การอุทธรณ์กรณีตรวจจับผิดพลาด

หากคุณเชื่อว่าคำขอถูกบล็อกอย่างไม่ถูกต้อง โปรดติดต่อฝ่ายสนับสนุนพร้อมระบุเวลาของคำขอ และ (หากสะดวก) request id เราจะตรวจสอบให้

ความเป็นส่วนตัว

คำขอทุกรายการจะถูกตรวจสอบเนื้อหาโดยอัตโนมัติ

คำขอที่พบว่าละเมิดนโยบายจะถูกเก็บเนื้อหาไว้เป็นหลักฐานการปฏิบัติตามข้อกำหนด

คำขออื่น ๆ จะไม่มีการเก็บเนื้อหาพรอมต์แบบเต็ม

อัตราจำกัด งบประมาณ และเบรกฉุกเฉิน

These controls can reject an otherwise valid request and require different recovery actions.

รูปแบบ error envelope แตกต่างตาม endpoint ใช้ HTTP status และ error.type เมื่อมี error.code อาจเป็น string หรือ numeric status และอาจไม่มี; error.message ใช้แสดงผลเท่านั้น

สถานะทรัพยากรวิดีโอและสื่อ

Video validation commonly returns numeric code 400. Missing jobs return 404, retired models 410, unfinished video content 409, and invalid video byte ranges 416.

ลองนโยบายอีกครั้ง

Retry only failures that may recover without changing the request. Honor Retry-After or use exponential backoff with jitter. Do not stack SDK and manual retries.

การจัดการข้อผิดพลาด

import random
import time
from openai import OpenAI, APIStatusError

client = OpenAI(
    base_url="https://api.bazaarlink.ai/v1",
    api_key="sk-bl-YOUR_API_KEY",
    max_retries=0,  # Avoid double retries; this example handles them.
)

RETRYABLE = {429, 502, 503, 504}

for attempt in range(5):
    try:
        response = client.chat.completions.create(
            model="openai/gpt-4o",
            messages=[{"role": "user", "content": "Hello!"}],
        )
        break
    except APIStatusError as error:
        if error.status_code not in RETRYABLE or attempt == 4:
            raise
        retry_after = error.response.headers.get("Retry-After")
        delay = (
            float(retry_after)
            if retry_after
            else min(8, 0.5 * (2 ** attempt)) + random.uniform(0, 0.25)
        )
        time.sleep(delay)

รูปแบบข้อผิดพลาด Streaming

Errors ที่เกิดขึ้นก่อนที่จะสตรีมโทเค็นใดๆ จะส่งกลับการตอบสนองข้อผิดพลาด HTTP มาตรฐานพร้อมเนื้อหา JSON

หลังจาก stream เริ่มแล้ว HTTP response จะเป็น 200 อยู่แล้ว ให้ parse SSE data frame ทุกเฟรม และถือว่า error ระดับบนสุด หรือ choices[0].finish_reason === "error" คือ response ที่ล้มเหลวและไม่สมบูรณ์

หาก stream ล้มเหลวหลังจากเริ่มแล้ว BazaarLink อาจส่ง SSE event สุดท้ายที่มี error object ระดับบนสุด ตามด้วย data: [DONE] ให้ถือว่า response ไม่สมบูรณ์ และอย่าใช้ output บางส่วนเป็นผลลัพธ์ที่เสร็จสมบูรณ์

data: {"error":{"message":"The request could not be completed.","type":"upstream_error","code":502}}

data: [DONE]

// Branch on error.code; error.type can vary by failure path.

เครื่องมือเรียก

Tool calling (หรือที่เรียกว่า function calling) ช่วยให้โมเดลเรียกใช้ฟังก์ชันภายนอกที่คุณกำหนด โมเดลจะตัดสินใจเมื่อจะเรียกเครื่องมือและสร้างอาร์กิวเมนต์ที่มีโครงสร้าง — โค้ดของคุณเรียกใช้ฟังก์ชันและส่งผลลัพธ์กลับเพื่อดำเนินการสนทนาต่อ

โมเดลที่รองรับ

โมเดลแนวหน้าส่วนใหญ่รองรับ tool calling ต่อไปนี้เป็นตัวเลือกยอดนิยม:

การกำหนดเครื่องมือ

แต่ละเครื่องมือเป็นออบเจ็กต์ JSON ที่อธิบายฟังก์ชันที่โมเดลสามารถเรียกใช้ ฟิลด์ parameters ใช้ JSON Schema

ตัวเลือก tool_choice

ขั้นตอนเต็ม

Tool calling เป็นกระบวนการหลายรอบ: (1) ส่งคำขอพร้อมเครื่องมือ → (2) โมเดลส่งคืน tool_calls → (3) เรียกใช้ฟังก์ชัน → (4) ส่งผลลัพธ์กลับ → (5) โมเดลสร้างการตอบกลับสุดท้าย

curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o",
    "messages": [{"role":"user","content":"What is the weather in Taipei?"}],
    "tools": [{
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
          "type": "object",
          "properties": {
            "city": {"type": "string", "description": "City name"},
            "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
          },
          "required": ["city"]
        }
      }
    }],
    "tool_choice": "auto"
  }'
# Response carries tool_calls — run get_weather() yourself, then send the
# result back with role:"tool" (same shape as the Python/TS steps 3-5) to
# get the model's final answer.

การเรียกเครื่องมือแบบขนาน

โมเดลบางตัวสามารถเรียกเครื่องมือหลายตัวในการตอบกลับเดียว จัดการแต่ละ tool call และส่งคืนผลลัพธ์ทั้งหมด:

# Model may return multiple tool_calls
if message.tool_calls:
    messages = [
        {"role": "user", "content": "Weather and time in Tokyo?"},
        message,
    ]

    for tool_call in message.tool_calls:
        # Execute each function
        if tool_call.function.name == "get_weather":
            result = {"temperature": 22, "condition": "Clear"}
        elif tool_call.function.name == "get_time":
            result = {"time": "2026-02-23T15:30:00+09:00"}

        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result),
        })

    # Send all results back at once
    final = client.chat.completions.create(
        model="openai/gpt-4o",
        messages=messages,
        tools=tools,
    )
    print(final.choices[0].message.content)

Tool Calls ระหว่างสตรีมมิง

เมื่อสตรีมมิง tool calls จะมาเป็น delta บางส่วนที่จัดทำดัชนีตามตำแหน่ง — สะสมสตริงอาร์กิวเมนต์ของแต่ละ delta ตามดัชนีจนกว่า finish_reason จะกลายเป็น "tool_calls" ซึ่งบ่งบอกว่าการเรียกเสร็จสมบูรณ์แล้ว

# Streaming: tool_calls arrive as partial deltas indexed by position —
# accumulate function.arguments per index until finish_reason == "tool_calls".
stream = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "What's the weather in Taipei?"}],
    tools=tools,
    tool_choice="auto",
    stream=True,
)

tool_calls = {}
for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.tool_calls:
        for tc in delta.tool_calls:
            entry = tool_calls.setdefault(tc.index, {"id": "", "name": "", "arguments": ""})
            if tc.id:
                entry["id"] = tc.id
            if tc.function.name:
                entry["name"] = tc.function.name
            if tc.function.arguments:
                entry["arguments"] += tc.function.arguments
    if chunk.choices[0].finish_reason == "tool_calls":
        for call in tool_calls.values():
            print(call["name"], json.loads(call["arguments"]))

ลูป Agent แบบง่าย

รูปแบบทั่วไปที่เรียกโมเดลต่อไปตราบใดที่โมเดลยังคงร้องขอเครื่องมือ และหยุดเมื่อโมเดลส่งคืนคำตอบสุดท้าย — ใช้ max_iterations เพื่อป้องกันการวนซ้ำไม่สิ้นสุด

# Generic loop: keep calling the model while it keeps requesting tools,
# stop once it returns a plain answer. max_iterations guards against loops.
messages = [{"role": "user", "content": "What's the weather in Taipei, and what time is it there?"}]
max_iterations = 10

for _ in range(max_iterations):
    response = client.chat.completions.create(
        model="openai/gpt-4o",
        messages=messages,
        tools=tools,
    )
    message = response.choices[0].message
    messages.append(message)

    if not message.tool_calls:
        break  # model gave a final answer

    for tool_call in message.tool_calls:
        args = json.loads(tool_call.function.arguments)
        result = TOOL_MAPPING[tool_call.function.name](**args)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result),
        })
else:
    print("Warning: max_iterations reached without a final answer")

print(messages[-1].content)

แนวทางปฏิบัติที่ดีที่สุดในการกำหนดฟังก์ชัน

• ใช้ชื่อที่เจาะจงและสื่อความหมาย — get_weather_forecast แทนที่จะเป็นแค่ weather
• เขียนคำอธิบายให้ชัดเจนว่าฟังก์ชันทำอะไรและควรใช้เมื่อไร — โมเดลอาศัยข้อความนี้เพียงอย่างเดียวในการตัดสินใจว่าจะเรียกหรือไม่
• จำกัดค่าด้วย enum เท่าที่ทำได้ และใส่ตัวอย่างในคำอธิบายเพื่อลดโอกาสที่อาร์กิวเมนต์จะผิดรูปแบบ
• ทำเครื่องหมาย required เฉพาะฟิลด์ที่จำเป็นจริง ๆ เท่านั้น ฟิลด์ที่เป็นทางเลือกควรละเว้นได้จริง

เอาต์พุตที่มีโครงสร้าง

บังคับให้โมเดลส่งคืน JSON ที่ถูกต้องตาม schema จำเป็นสำหรับการสร้างแอปพลิเคชันที่เชื่อถือได้ที่แยกวิเคราะห์เอาต์พุตโมเดลด้วยโปรแกรม

วิธีที่ 1: response_format (JSON Schema)

เพื่อบังคับให้เป็นไปตาม JSON Schema อย่างเคร่งครัด:

curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o",
    "messages": [{"role":"user","content":"Review the movie Inception"}],
    "response_format": {
      "type": "json_schema",
      "json_schema": {
        "name": "movie_review",
        "strict": true,
        "schema": {
          "type": "object",
          "properties": {
            "title": {"type": "string"},
            "rating": {"type": "integer", "description": "Rating 1-10"},
            "summary": {"type": "string"},
            "pros": {"type": "array", "items": {"type": "string"}},
            "cons": {"type": "array", "items": {"type": "string"}}
          },
          "required": ["title", "rating", "summary", "pros", "cons"],
          "additionalProperties": false
        }
      }
    }
  }'

เคล็ดลับ

• ใช้ชื่อ property ที่ชัดเจนและอธิบายได้ — โมเดลใช้เป็นบริบท
• เพิ่ม descriptions ให้กับ schema properties เพื่อแนะนำโมเดล
• ตั้ง strict: true เพื่อรับประกันการเป็นไปตาม schema (อาจเพิ่มเวลาแฝงเล็กน้อย)
• ทำ schema ให้เรียบง่าย — schema ที่ซ้อนกันลึกอาจลดคุณภาพเอาต์พุต
• ทดสอบกับโมเดลต่างๆ — บางตัวจัดการ schema ที่ซับซ้อนได้ดีกว่าตัวอื่น

เครื่องช่วยเติมล่วงหน้า

เพิ่มข้อความ assistant ที่ยังไม่สมบูรณ์เป็นรายการสุดท้าย เพื่อขอให้สร้างต่อบนเส้นทางโมเดลที่รองรับ

curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-4.6",
    "messages": [
      {"role":"user","content":"What is the capital of France?"},
      {"role":"assistant","content":"The capital of France is"}
    ]
  }'
# Model continues: " Paris, known for the Eiffel Tower..."

การแปลงข้อความ

The client-supplied transforms field is ignored and removed before an upstream request. It cannot enable or disable message transformations. BazaarLink may apply context handling under its own server-side rules; shorten the input or select a model with a larger context window when needed.

Zero การเก็บรักษาข้อมูล

BazaarLink จะไม่จัดเก็บเนื้อหาข้อความของคุณตามค่าเริ่มต้น หน้านี้อธิบายวิธีจัดการข้อมูลของคุณ เหมาะสำหรับแอปพลิเคชันที่ประมวลผลข้อมูลที่ละเอียดอ่อน

การจัดการข้อมูลปัจจุบัน

• เนื้อหาข้อความ: ไม่ได้จัดเก็บตามค่าเริ่มต้น จะถูกละทิ้งจากหน่วยความจำหลังการประมวลผล
• ข้อมูลเมตาการเรียกเก็บเงิน: จำนวนโทเค็น การประทับเวลา รหัสโมเดล
• Usage บันทึก: ขอสถิติเท่านั้น ไม่มีเนื้อหาข้อความ
• การส่งต่ออัปสตรีม: ข้อความที่ส่งต่อไปยังผู้ให้บริการอัปสตรีม — ขึ้นอยู่กับนโยบายความเป็นส่วนตัว

การแคชพร้อมท์

Prompt caching จะนำโทเค็นพร้อมต์ที่คำนวณไว้ก่อนหน้านี้กลับมาใช้ใหม่ ซึ่งช่วยลดต้นทุนและเวลาในการตอบสนองได้อย่างมาก โดยเฉพาะอย่างยิ่งสำหรับแอปพลิเคชันที่มีพร้อมต์ของระบบขนาดใหญ่และซ้ำกัน

วิธีการทำงาน

การต้องตั้งค่าหรือไม่ขึ้นอยู่กับผู้ให้บริการ โมเดลตระกูล OpenAI จะแคช prefix ของ prompt ที่ยาวและซ้ำโดยอัตโนมัติ — ไม่ต้องแก้ไข request โมเดล Claude (Anthropic) จะแคชก็ต่อเมื่อ request มี cache_control breakpoint อย่างชัดเจนเท่านั้น BazaarLink ไม่ได้เพิ่มสิ่งนี้ให้คุณ ดังนั้น request ของ Claude ที่ไม่มี marker จะไม่ถูกแคชเลย BazaarLink ส่งต่อ cache marker ที่คุณส่งมาโดยไม่เปลี่ยนแปลง และรายงานจำนวนโทเค็นที่อ่าน/เขียนแคชจริงในการตอบกลับ usage

# OpenAI-family models: nothing to add, long repeated prefixes cache automatically.
response = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[
        {"role": "system", "content": "You are an expert..."},  # cached automatically if long/repeated
        {"role": "user", "content": "Question here"},
    ],
)

# Check cache savings in the response usage
usage = response.usage
print(f"Prompt tokens: {usage.prompt_tokens}")
print(f"Cached tokens: {usage.prompt_tokens_details.cached_tokens}")
print(f"Cache savings: {usage.prompt_tokens_details.cached_tokens / usage.prompt_tokens * 100:.1f}%")

# Claude models: you must mark the block to cache yourself.
response = client.chat.completions.create(
    model="anthropic/claude-sonnet-4.6",
    messages=[
        {
            "role": "system",
            "content": [
                {"type": "text", "text": "You are an expert...", "cache_control": {"type": "ephemeral"}}
            ],
        },  # BazaarLink does not add cache_control on your behalf
        {"role": "user", "content": "Question here"},
    ],
)

usage = response.usage
print(f"Cache read tokens: {getattr(usage, 'cache_read_input_tokens', 0)}")
print(f"Cache write tokens: {getattr(usage, 'cache_creation_input_tokens', 0)}")

โทเค็นเหตุผล

แบบจำลองเหตุผล (เช่น DeepSeek R1, ซีรีส์ o1) คิดแบบภายในก่อนที่จะสร้างคำตอบสุดท้าย โทเค็นภายในเหล่านี้เรียกว่าโทเค็นการให้เหตุผล และจะเรียกเก็บเงินแยกต่างหาก

การอ่านโทเค็นการใช้เหตุผลจากการตอบกลับ

response = client.chat.completions.create(
    model="deepseek/deepseek-r1",
    messages=[{"role": "user", "content": "Solve: if f(x) = x^2 + 3x, what is f(5)?"}],
)

# Read reasoning tokens from usage
usage = response.usage
print(f"Completion tokens: {usage.completion_tokens}")
if hasattr(usage, "completion_tokens_details"):
    details = usage.completion_tokens_details
    print(f"Reasoning tokens: {details.reasoning_tokens}")
    print(f"Output tokens: {details.accepted_prediction_tokens}")

const response = await client.chat.completions.create({
  model: "openai/gpt-5.5",
  messages: [{ role: "user", content: "Prove that sqrt(2) is irrational." }],
  // @ts-ignore - BazaarLink extension
  reasoning_effort: "high",  // low | medium | high
});

const usage = response.usage;
console.log("Reasoning tokens:", usage?.completion_tokens_details?.reasoning_tokens);

การควบคุมโหมดการคิด

บางรุ่นรองรับการสลับโหมด "การคิด" โหมดการคิดจะสร้างโทเค็นการให้เหตุผลภายในก่อนที่จะสร้างคำตอบสุดท้าย ซึ่งจะช่วยปรับปรุงคุณภาพโดยเสียโทเค็นมากขึ้น

# Qwen3: explicitly enable thinking mode
response = client.chat.completions.create(
    model="qwen/qwen3.7-flash",
    messages=[{"role": "user", "content": "Prove the Pythagorean theorem"}],
    extra_body={"enable_thinking": True},  # opt-in to thinking
)

# usage.completion_tokens_details.reasoning_tokens shows thinking token count

ออบเจ็กต์การให้เหตุผลแบบรวม (รูปแบบใหม่)

BazaarLink ยังสนับสนุนอ็อบเจ็กต์การให้เหตุผลแบบรวม ซึ่งใช้ได้กับตระกูลโมเดลทั้งหมดด้วย API เดียวที่สอดคล้องกัน:

// Claude extended thinking — specify thinking budget in tokens
const response = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-4.5",
  messages: [{ role: "user", content: "Prove the Pythagorean theorem" }],
  // @ts-ignore - BazaarLink extension
  reasoning: { max_tokens: 5000 },
});

// OpenAI GPT-5.6 Sol — specify effort level
const response2 = await client.chat.completions.create({
  model: "openai/gpt-5.6-sol",
  messages: [{ role: "user", content: "Solve this math problem..." }],
  // @ts-ignore - BazaarLink extension
  reasoning: { effort: "high" },
});

// Hide thinking content from response (model still thinks)
const response3 = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-4.5",
  messages: [{ role: "user", content: "What is 2+2?" }],
  // @ts-ignore - BazaarLink extension
  reasoning: { max_tokens: 2000, exclude: true },
});

การอ่านเนื้อหาความคิด

โมเดล reasoning สามารถส่งเนื้อหาความคิดกลับมาพร้อมคำตอบได้ โมเดลที่แสดงด้านล่างเปิดการคิดโดยค่าเริ่มต้น: คำขอที่ไม่ส่งพารามิเตอร์ reasoning ใดๆ จะทำงานโดยเปิดการคิด ส่งเนื้อหาความคิดกลับ และคิดเงินตามโทเค็นการคิดที่ใช้จริง ส่ง reasoning: { exclude: true } หรือ include_reasoning: false เพื่อปิด โมเดลอื่นทั้งหมดจะส่งเนื้อหาความคิดกลับเฉพาะเมื่อคุณร้องขอ: ส่ง reasoning_effort, ออบเจกต์ reasoning, include_reasoning: true, thinking หรือ enable_thinking

โมเดลที่คิดโดยค่าเริ่มต้น: gemini-4-argon, deepseek-v4.1-flash, deepseek-v4.1-flash-1017

วิธีร้องขอ

ใส่อย่างใดอย่างหนึ่งต่อไปนี้ในคำขอ: reasoning_effort (low, medium หรือ high), ออบเจกต์ reasoning (effort, max_tokens), include_reasoning: true, thinking: { type: "enabled" } หรือ enable_thinking: true ส่ง reasoning.exclude: true หรือ include_reasoning: false เพื่อปิดเนื้อหาความคิด (โมเดลยังคงใช้เหตุผลอยู่)

ตรวจสอบระดับที่แต่ละโมเดลรองรับด้วย GET /v1/models: โมเดล reasoning แต่ละตัวจะแสดง reasoning.supported_efforts, reasoning.default_effort และ reasoning.mandatory (เช่น gemini-4-argon รองรับ high, medium และ low)

ตัวอย่าง: gemini-4-argon

response = client.chat.completions.create(
    model="gemini-4-argon",
    messages=[{"role": "user", "content": "Which is larger, 9.11 or 9.9?"}],
    reasoning_effort="high",  # or: extra_body={"include_reasoning": True}
)

message = response.choices[0].message
print(message.reasoning)          # the thinking text (only returned because we asked)
print(message.content)            # the answer

const stream = await client.chat.completions.create({
  model: "gemini-4-argon",
  messages: [{ role: "user", content: "Which is larger, 9.11 or 9.9?" }],
  stream: true,
  // @ts-ignore - BazaarLink extension
  reasoning: { effort: "high" },
});

for await (const chunk of stream) {
  const delta: any = chunk.choices[0]?.delta;
  if (delta?.reasoning) process.stdout.write(delta.reasoning); // thinking text
  if (delta?.content) process.stdout.write(delta.content);     // answer
}

ที่ /v1/responses ให้ร้องขอด้วย reasoning: { effort, summary: "auto" } เนื้อหาความคิดจะอยู่ในรายการ reasoning ของอาร์เรย์ output ส่วนที่ /v1/messages ให้ส่ง thinking: { type: "enabled", budget_tokens } เพื่อรับบล็อก thinking

เวลาแฝงและประสิทธิภาพ

การเพิ่มประสิทธิภาพ AI API เวลาตอบสนองเป็นสิ่งสำคัญสำหรับประสบการณ์ของผู้ใช้ ด้านล่างนี้คือปัจจัยสำคัญที่ส่งผลต่อเวลาแฝงในสถาปัตยกรรม BazaarLink และแนวทางปฏิบัติที่ดีที่สุดในการปรับให้เหมาะสม

ปัจจัยที่ส่งผลต่อเวลาในการตอบสนอง

• ขนาดโมเดล: โมเดลขนาดใหญ่ (70B+) โดยทั่วไปจะสร้างช้ากว่า
• โหลดของผู้ให้บริการ: แตกต่างกันไปตามผู้ให้บริการและเวลาของวัน
• Token จำนวน: max_tokens ที่สูงขึ้นหมายถึงเวลาดำเนินการเสร็จสิ้นนานขึ้น
• การสตรีมกับการไม่สตรีม: สตรีม: true มอบโทเค็นแรกเร็วขึ้น
• ความยาวของบริบท: บริบทที่ยาวมากจะทำให้เวลาก่อนการประมวลผลเพิ่มขึ้น

เคล็ดลับการเพิ่มประสิทธิภาพ

• ต้องการสตรีมมิง (สตรีม: จริง) เพื่อปรับปรุงการรับรู้เวลาแฝง
• เลือกรุ่นที่เล็กกว่า (flash/mini/haiku) สำหรับสถานการณ์ที่ไวต่อความหน่วง
• เปิดใช้งานการแคชพร้อมท์เพื่อลดเวลาแฝงสำหรับคำขอซ้ำ

import time

# Measure time to first token with streaming
start = time.time()
first_token_time = None

stream = client.chat.completions.create(
    model="google/gemini-3.5-flash",  # Fast model
    messages=[{"role": "user", "content": "Hello!"}],
    stream=True,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content and not first_token_time:
        first_token_time = time.time() - start

print(f"Time to first token: {first_token_time:.3f}s")

# Look up per-request latency and throughput after the fact, using the
# generation ID from the response (or the final streamed chunk).
curl "https://api.bazaarlink.ai/v1/generation?id=BAZAARLINK_REQUEST_ID" \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY"

# Response
{
  "data": {
    "id": "85e6f35c71a31f19-SJC",
    "model": "google/gemini-3.5-flash",
    "duration_ms": 842,
    "throughput": 61.2,
    "usage": { "prompt_tokens": 12, "completion_tokens": 48, "total_tokens": 60 }
  }
}

การเพิ่มประสิทธิภาพเวลาทำงาน

หลังเกิดข้อผิดพลาดจาก upstream คำขออาจลองใช้แหล่งอื่นที่พร้อมใช้งานได้ หากไม่มีแหล่งที่ประมวลผลคำขอได้ คำขอจะได้รับข้อผิดพลาด Circuit breaker จำกัดการลองซ้ำ และมีการตรวจสอบสถานะผู้ให้บริการ

กลไกความพร้อมใช้งาน

• Circuit breaker: ตรวจจับอัตโนมัติและแยกผู้ให้บริการที่ล้มเหลว
• เมื่อแหล่ง upstream มีปัญหา คำขออาจลองใช้แหล่งอื่นที่พร้อมใช้งานได้ หากไม่มีแหล่งใดใช้ได้ คำขอจะได้รับข้อผิดพลาด
• การตรวจสอบสภาพของผู้ให้บริการ: ติดตามอัตราข้อผิดพลาดและเวลาแฝงต่อผู้ให้บริการอย่างต่อเนื่อง
• ตรรกะการลองใหม่: ข้อผิดพลาดชั่วคราว (5xx) จะถูกลองใหม่โดยอัตโนมัติ

เซอร์กิตเบรกเกอร์

# If an upstream source returns an error, the request can try another available source.
# Requests handled by a platform model are billed at that model's catalog price.

response = client.chat.completions.create(
    model="openai/gpt-4o",       # Primary model
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={
        "models": [              # Local fallback chain, tried in order
            "openai/gpt-4o",
            "anthropic/claude-sonnet-4.6",
            "google/gemini-3.5-flash",
        ],
    },
)

# Check whether another source handled the request (in usage logs)
# "is_failover": true indicates the primary provider was bypassed

ราวกันตก

เพิ่มกลไกความปลอดภัยของเนื้อหาให้กับคำขอ API ของคุณ เพื่อกรองเนื้อหาที่เป็นอันตรายและบังคับใช้นโยบายการปฏิบัติตามข้อกำหนด BazaarLink มี guardrail กรองเนื้อหาที่ปรับแต่งได้เฉพาะระดับองค์กร (Organization) เท่านั้นในขณะนี้ คีย์ API ส่วนบุคคล (ที่ไม่ใช่ขององค์กร) ไม่มีการตั้งค่าที่เทียบเท่า — ความปลอดภัยของเนื้อหาขึ้นอยู่กับระบบความปลอดภัยในตัวของผู้ให้บริการโมเดลต้นทางแต่ละรายทั้งหมด

ฟีเจอร์ที่วางแผนไว้ (ยังไม่มีทั้งคีย์ส่วนบุคคลและองค์กร)

พฤติกรรมปัจจุบัน

คีย์ API ส่วนบุคคล: ผู้ให้บริการต้นทางทุกรายมีระบบความปลอดภัยเนื้อหาของตนเอง การตอบกลับของโมเดลที่กระตุ้นตัวกรองเนื้อหาจะส่งคืนพร้อม finish_reason: "content_filter" และ BazaarLink จะไม่กรองเพิ่มเติม คีย์ API องค์กร: org_admin สามารถตั้งค่ากฎที่กำหนดเอง (บล็อก/ปกปิด/บันทึก) ได้ที่ "Content Filter Guardrails" ซึ่งจะถูกใช้ก่อนที่ข้อความจะไปถึงโมเดล

เคอร์เซอร์ IDE บูรณาการ

ตั้ง BazaarLink เป็น Override URL ของ OpenAI ใน Cursor. ตั้งค่าพร้อมแปลง Responses API อัตโนมัติ, normalize รูปแบบ tool, และ prefix bz- สำหรับโมเดล Claude.

ตั้งค่าด่วน

ใน Cursor เปิด Settings → Models แล้ว:

1. ตั้ง Override OpenAI Base URL เป็น https://api.bazaarlink.ai/v1
2. ตั้ง Override OpenAI API Key เป็นคีย์ BazaarLink sk-bl-... ของคุณ
3. เพิ่มชื่อโมเดลที่ต้องการ — ดูด้านล่างสำหรับ Claude (prefix bz-).

Prefix bz- (สำหรับโมเดล Claude)

การตรวจสอบฝั่งไคลเอนต์ของ Cursor จะเปลี่ยนเส้นทางชื่อโมเดลที่ขึ้นต้นด้วย claude- ผ่านการเชื่อมต่อ Anthropic ของ Cursor เอง โดยข้าม Override URL ของคุณ หากต้องการให้ Cursor ส่งคำขอไปยัง BazaarLink ให้เพิ่ม prefix bz- ที่ชื่อโมเดล เซิร์ฟเวอร์จะลบ prefix และ resolve ส่วนที่เหลือผ่าน alias map

ตัวแปรจุดและขีดกลางถูก normalize: bz-claude-sonnet-4.6 และ bz-claude-sonnet-4-6 ทั้งคู่แปลงเป็นโมเดลเดียวกัน

CURSOR_MODEL_MAP env var (override โดยผู้ดูแล)

สำหรับการติดตั้ง BazaarLink แบบโฮสต์เอง ตั้งค่า env var นี้เพื่อแมปชื่อโมเดลฝั่ง Cursor ใหม่ไปยัง canonical id ของแคตตาล็อก:

CURSOR_MODEL_MAP=gpt-claude-sonnet:anthropic/claude-sonnet-4.6,gpt-opus:anthropic/claude-opus-4.7

ตอนนี้ gpt-claude-sonnet ที่พิมพ์ใน Cursor จะถูก map เป็น anthropic/claude-sonnet-4.6 ฝั่งเซิร์ฟเวอร์ มีประโยชน์เมื่อคุณต้องการให้ Cursor คิดว่าโมเดลเป็นตระกูล GPT (เพื่อ route ผ่าน Override URL) ในขณะที่จริงๆ คุณให้บริการ Claude

สิ่งที่เกิดขึ้นโดยอัตโนมัติ

เมื่อคำขอมาถึง /v1/chat/completions, BazaarLink จะใช้การแปลงความเข้ากันได้เหล่านี้อย่างโปร่งใส — คุณไม่ต้องทำอะไรในฝั่ง client:

• ตรวจจับ Responses API body อัตโนมัติ — ถ้า body มี input แทน messages จะแปลงเป็นรูปแบบ Chat Completions (Cursor ส่งรูปแบบ Responses API สำหรับโมเดลตระกูล GPT)
• ครอบ flat tool definitions — Cursor Agent ส่ง { name, description, parameters } โดยไม่มี function wrapper เราครอบให้เพื่อไม่ให้ Anthropic ปฏิเสธว่า Tool '' not found in provided tools
• บังคับให้ tool_choice ที่ไม่ถูกต้องเป็นรูปแบบที่ถูกต้อง — Cursor ส่ง { type: "auto" } (รูปแบบอ็อบเจกต์ ไม่มี function) ข้อกำหนด OpenAI ต้องการรูปแบบสตริงสำหรับ auto/none/required เราจึงบังคับแปลง
• ตัดฟิลด์เฉพาะ OpenAI เมื่อ route ไปยังผู้ให้บริการที่ไม่ใช่ OpenAI — parallel_tool_calls, logprobs, top_logprobs, logit_bias, service_tier, user ถูกลบก่อนส่งต่อ (มิฉะนั้น Anthropic จะคืน 400)
• Map max_output_tokens → max_tokens และตัดฟิลด์เฉพาะ Responses-API (previous_response_id, truncation, background, store) ฟิลด์ reasoning ถูกเก็บไว้สำหรับ body Chat-Completions ดั้งเดิม

โหมด Cursor Agent

การเรียกใช้ทูลทำงานผ่านโฟลว์ tool-call ของ Chat Completions มาตรฐาน Cursor ส่ง tools (Shell, Read, Write, Grep ฯลฯ) พร้อม tool_choice: "auto"; BazaarLink ส่งต่อไปยังผู้ให้บริการที่คุณเลือก ซึ่งตัดสินใจว่าจะเรียกใช้ทูลหรือไม่ การเรียกใช้ทูลส่งกลับเป็น tool_calls deltas มาตรฐานของ OpenAI; Cursor ดำเนินการในเครื่องและสนทนาต่อ ทำงานเหมือนกันไม่ว่าคุณจะเลือก gpt-4o (OpenAI ดั้งเดิม) หรือ bz-claude-sonnet-4.6

การกำหนดเส้นทางโมเดล

BazaarLink ใช้รูปแบบ provider/model-name เพื่อกำหนดเส้นทางคำขอไปยังผู้ให้บริการ upstream ที่ถูกต้อง ให้คุณเข้าถึงโมเดลหลักผ่าน API endpoint เดียว

รูปแบบ Model ID

{provider}/{model-name}

# Examples
openai/gpt-5.4-mini
anthropic/claude-sonnet-4.6
google/gemini-3-flash-preview
deepseek/deepseek-v4.1-flash

ลำดับความสำคัญการกำหนดเส้นทาง

เมื่อคุณส่งคำขอ BazaarLink จะแก้ไขผู้ให้บริการ upstream ตามลำดับนี้:

1. จับคู่แน่นอน — ค้นหาเส้นทางโมเดลที่ตรงกับ model ID เต็ม
2. Wildcard ผู้ให้บริการ — สำรองไปยังเส้นทาง provider/* (เช่น openai/*)
3. Wildcard ทั่วไป — สำรองไปยังเส้นทาง * wildcard
4. คีย์ผู้ให้บริการเริ่มต้น — ใช้เฉพาะโมเดลที่อยู่ในแค็ตตาล็อก โดยเลือกคีย์ที่เปิดใช้งานและกำหนดเป็นค่าเริ่มต้น

เรียกดูโมเดลที่พร้อมใช้งานทั้งหมดบน หน้าโมเดล

เราเตอร์อัตโนมัติ

Auto Router v3 scores the request into one of 14 task tiers, then uses the current primary and fallback chain configured for that tier. Paid and free tables are managed separately in the admin console.

• auto — ตารางเส้นทางแบบชำระเงิน แบบจำลองที่แก้ไขสำเร็จจะถูกเรียกเก็บเงินตามราคาที่เผยแพร่
• auto:free — ตารางเส้นทางฟรี การโทรภายในโควต้าฟรีมีค่าใช้จ่าย $0; หลังจากโควต้า บัญชีที่ได้รับทุนอาจเปลี่ยนไปใช้การกำหนดเส้นทางอัตโนมัติแบบชำระเงิน เว้นแต่จะปิดใช้ทางเลือกแบบชำระเงิน

วิธีใช้

ตั้งค่าโมเดลเป็น "auto" (ชำระเงิน) หรือ "auto:free" (ฟรี) เพื่อเปิดใช้งานการกำหนดเส้นทางอัตโนมัติ:

curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"auto","messages":[{"role":"user","content":"Review this TypeScript function"}]}'

วิธีที่ v3 เลือกระดับ

General tiers are simple, standard, complex and reasoning. Specialized tiers are coding, vision, image, video, data, search, social, email, calendar and trading. Low-confidence boundary results are promoted one level.

• Tier การให้คะแนน: ข้อความ เครื่องมือ ความยาว คำสำคัญ และสัญญาณโครงสร้าง เลือกหนึ่งใน 14 ระดับ
• การแทนที่แบบยาก: วิสัยทัศน์ การใช้เหตุผลอย่างเป็นทางการ และงานเฉพาะทาง สามารถเลือกระดับได้โดยตรง
• Route lookup: reads the current primary and up to five fallbacks; a disabled tier returns 503
• Execution: tries the primary, then the configured fallback chain in order
• การติดตามการตอบสนอง: โมเดลที่ได้รับการแก้ไขแล้วจะถูกส่งกลับในส่วนเนื้อหาการตอบสนองและส่วนหัว X-Auto-Resolved-Model

ตารางรุ่นปัจจุบัน

These tables use the same live configuration as inference and admin. Primary models, fallback order and enabled state can change without a deployment.

auto

auto:free

บางโมเดลมีระดับใช้งานฟรีแบบจำกัดอัตรา สิทธิ์ใช้ฟรีถูกกำหนดต่อโมเดลโดยแพลตฟอร์ม — เรียกใช้ด้วย ID โมเดลปกติได้เลย ส่วนต่อท้าย :free เป็นเพียงชื่อแทนเสริม (เติมให้โมเดลเสียเงินไม่ทำให้ฟรี)

รุ่นต่างๆ

รหัสรุ่นอิสระ

รูปแบบในแค็ตตาล็อก เช่น :free, :extended และ :thinking อาจระบุรายการที่มีความสามารถหรือราคาในแค็ตตาล็อกแตกต่างกัน เส้นทาง upstream และราคาสำหรับลูกค้ากำหนดตามแค็ตตาล็อกและกฎฝั่งเซิร์ฟเวอร์ของ BazaarLink

:free
:extended
:thinking

:nitro
:floor
:exacto

:online

โมเดลฟรี

บางโมเดลมีระดับใช้งานฟรีแบบจำกัดอัตรา สิทธิ์ใช้ฟรีถูกกำหนดต่อโมเดลโดยแพลตฟอร์ม — เรียกใช้ด้วย ID โมเดลปกติได้เลย ส่วนต่อท้าย :free เป็นเพียงชื่อแทนเสริม (เติมให้โมเดลเสียเงินไม่ทำให้ฟรี)

• เรียกใช้ ID โมเดลปกติ (เช่น deepseek/deepseek-v4-flash) คำขอภายในโควตาฟรีจะได้รับบริการฟรีโดยอัตโนมัติ
• การใช้งานฟรีถูกจำกัดต่อผู้ใช้ด้วยจำนวนคำขอต่อนาทีและเพดานรายวัน ขีดจำกัดปรับตามระดับบัญชี (ไม่มีเครดิต / มีเครดิต)
• เมื่อเกินโควตาฟรีและมีเครดิต คำขอจะดำเนินต่อในระดับเสียเงินตามราคาที่แสดงโดยอัตโนมัติ ส่ง X-Free-Fallback: false เพื่อปิดการสลับอัตโนมัติและรับ 429 แทน หากไม่มีเครดิต คำขอที่เกินโควตาจะได้ 429
• GET /v1/models แสดงรายการ :free สำหรับทุกโมเดลที่มีระดับฟรี ส่วน auto:free จะกำหนดเส้นทางไปยังโมเดลฟรีเสมอ

โมเดลที่มีโควตาฟรีตอนนี้

เรียกใช้ ID โมเดลเหล่านี้ได้โดยตรงเพื่อใช้โควตาฟรี รายการอาจเปลี่ยนแปลง แนะนำให้ดึงรายการล่าสุดผ่าน API

qwen/qwen3.7-flash
reflection/beam-free
nvidia/nemotron-3.5-lightning-free
reflection/beam
stealth/glyph-cluster
deepseek/deepseek-v4-flash-0731free

ขีดจำกัดโควตาฟรี

งบต่อวันของคุณ = งบคำขอต่อวันด้านบน × ตัวคูณระดับบัญชี โดยนับแยกแต่ละโมเดลฟรี ส่วน auto:free ยังมีเพดานคู่ขนานต่อ IP อีกชั้น โมเดลแต่ละตัวอาจถูกตั้งขีดจำกัดเข้มหรือผ่อนกว่านี้ ค่าที่ใช้จริงแสดงในบล็อก "โควตาฟรี" บนหน้าโมเดล โควตาฟรีคิดเป็น "หน่วย" ไม่ใช่จำนวนคำขอเพียงอย่างเดียว: หน่วยที่ใช้ต่อคำขอจะเพิ่มขึ้นตามความยาว context ของ prompt ดังนั้นภายใต้โควตารายวันเท่ากัน คำขอที่มี context ยาวจะใช้งานได้จริงน้อยกว่า prompt สั้นอย่างชัดเจน

หลังใช้โควตาฟรีหมด

เมื่อใช้โควตาฟรีหมดแล้ว คำขอส่วนเกินจะคิดตามราคาแบบชำระเงินของโมเดลหากบัญชียังมียอดเงิน หากต้องการรับ 429 แทน ให้ส่ง `X-Free-Fallback: false` หรือปิดการเปลี่ยนไปใช้ระดับชำระเงินในการตั้งค่าคีย์ หากไม่มียอดเงิน คำขอที่เกินโควตาจะส่งคืน 429

เมื่อคำขอถูกลดระดับแบบนี้จริง การตอบกลับจะมีเฮดเดอร์ x-bl-free-fallback: daily หรือ x-bl-free-fallback: rpm ระบุว่าโควตาใดถูกกระตุ้น ทำให้คุณตรวจพบการสลับได้ตั้งแต่ตอนที่ส่งคำขอ ไม่ต้องรอดูจากบิล คำขอที่ไม่ได้ถูกลดระดับจะไม่มีเฮดเดอร์นี้

# Return 429 instead of switching to paid routing
-H "X-Free-Fallback: false"

การจัดการองค์กร

BazaarLink organizations use a three-tier architecture: Organization → Team → Member. Credits are stored at the org level; each Team and member can have a monthly spend cap. API requests check member → team → org credits in sequence.

ระบบงบประมาณสามชั้น

On every API request, three budget layers are checked in order. Exceeding any layer returns HTTP 429:

1. Member งบประมาณรายเดือน (OrgMember.monthlyBudget)
2. งบประมาณรายเดือนของทีม (Team.monthlyBudget)
3. ยอดเครดิตองค์กร (Organization.credits)

รายงานการใช้งาน

The Reports page in the org portal provides monthly spend analytics across four dimensions:

• ภาพรวม: การใช้จ่ายทั้งหมด อัตรามาร์จิ้น แผนภูมิแนวโน้มรายวัน
• ตามทีม: การใช้จ่ายต่อทีม, ส่วนแบ่ง %, การแยกย่อยแบบจำลอง, การใช้งบประมาณ
• By Model: การใช้จ่ายต่อโมเดล, ราคาเฉลี่ย ($/1M tokens)
• By Member: การใช้จ่ายต่อสมาชิก — org_admin เท่านั้น

มุมมองทั้งหมดรองรับการส่งออก CSV ด้วยคำนำหน้า BOM สำหรับความเข้ากันได้ของ Excel โดยตรง

สร้างและจัดการองค์กร

1. Go to Settings → Organizations → Create New Organization
2. Create Teams in the org portal (optional: cost center code and monthly budget)
3. Invite members by email, assign a role and Team
4. Issue API keys for members — usage is automatically tagged to the correct Team / member
5. View the Reports page for monthly spend broken down by Team, Model, or Member
6. ดูหน้ารายงานการใช้จ่ายรายเดือนโดยแยกตามทีม รุ่น หรือสมาชิก

บทบาทสมาชิก

องค์กรสามารถจัดการอะไรได้อีก?

นอกเหนือจากสมาชิกและทีมงานแล้ว พื้นที่การจัดการองค์กรยังจัดให้มี:

• API keys and model restrictions
• Content filtering before text reaches a model
• Allowed Models by organization, team, member, or key
• Monthly budgets and spend emergency brakes
• Reports and billing
• Change logs and security logs

curl https://api.bazaarlink.ai/v1/orgs \
  -H "Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY"

# Create a team
curl https://api.bazaarlink.ai/v1/orgs/{orgId}/teams \
  -X POST \
  -H "Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Engineering", "costCenterCode": "ENG-001", "monthlyBudget": 500}'

# Add a member
curl https://api.bazaarlink.ai/v1/orgs/{orgId}/members \
  -X POST \
  -H "Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "alice@example.com", "role": "member", "monthlyBudget": 50}'

# Remove a member
curl https://api.bazaarlink.ai/v1/orgs/{orgId}/members/{memberId} \
  -X DELETE \
  -H "Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY"

# Monthly overview via management key
curl "https://bazaarlink.ai/api/orgs/{orgId}/reports/overview?year=2026&month=3" \
  -H "Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY"

# By-team breakdown
curl "https://bazaarlink.ai/api/orgs/{orgId}/reports/by-team?year=2026&month=3" \
  -H "Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY"

# Export CSV (downloads file)
curl "https://bazaarlink.ai/api/orgs/{orgId}/reports/export?year=2026&month=3&view=by-team" \
  -H "Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY" \
  -o report.csv

ตารางอ้างอิง Error Response

โมเดลที่อนุญาต (Whitelist)

จำกัดว่าองค์กร ทีม หรือสมาชิกแต่ละคนสามารถเรียกโมเดลใดได้บ้าง เหมาะสำหรับบล็อกโมเดลที่มีค่าใช้จ่ายสูงหรือยังไม่ผ่านการตรวจสอบ บังคับใช้มาตรฐานโมเดล หรือจำกัดทีมให้ใช้เฉพาะ provider เดียว

หลักการทำงาน

• สามชั้นที่เป็นอิสระจากกัน — Organization, Team, Member — แต่ละชั้นมี list ของตัวเอง (String[] ใน database)
• เมื่อทั้งสามชั้นว่างหมด ทุกโมเดลจะถูกอนุญาต (พฤติกรรมเริ่มต้น)
• เมื่อมีอย่างน้อยหนึ่งชั้นที่ไม่ว่าง list ที่มีผลคือ intersection ของชั้นที่ไม่ว่าง — โมเดลต้องผ่านทุกชั้นที่ถูกจำกัดจึงจะใช้ได้
• การเปลี่ยนแปลงมีผลภายในไม่กี่วินาที (cache 60 วินาทีใน memory + 5 นาทีใน Redis ทั้งคู่ถูกล้างเมื่อมีการอัปเดต)

รูปแบบ pattern

• Exact match — เช่น openai/gpt-4o (ตรงกับโมเดลนี้เท่านั้น)
• Provider wildcard — เช่น openai/* (ทุกโมเดลภายใต้ prefix openai/)
• ตัวพิมพ์เล็กเท่านั้น สูงสุด 200 entry ต่อ list, 100 ตัวอักษรต่อ entry

ที่จัดการ

Org Portal → Allowed Models org_admin แก้ list ของ org / team / member ได้ทั้งหมด team_admin แก้ทีมของตนเองและสมาชิกในทีมนั้นได้

Error response เมื่อถูกบล็อก

การเรียกโมเดลที่ไม่อนุญาตจะได้ HTTP 403 พร้อม body แบบนี้:

HTTP/1.1 403 Forbidden
Content-Type: application/json

{
  "error": {
    "message": "Model is not allowed for this account",
    "code": "model_not_allowed"
  }
}

การจัดการ API

ทุก endpoint รองรับ Web Session หรือ Bearer Management Key (sk-bl-...) PATCH จะแทนที่ list ทั้งหมด ส่ง [] เพื่อล้างค่า

# Org-level list
GET    /api/orgs/:orgId/allowed-models
PATCH  /api/orgs/:orgId/allowed-models

# Team-level list
GET    /api/orgs/:orgId/teams/:teamId/allowed-models
PATCH  /api/orgs/:orgId/teams/:teamId/allowed-models

# Member-level list
GET    /api/orgs/:orgId/members/:memberId/allowed-models
PATCH  /api/orgs/:orgId/members/:memberId/allowed-models

# Example: restrict an org to OpenAI + a specific Anthropic model
curl -X PATCH https://bazaarlink.ai/api/orgs/$ORG_ID/allowed-models \
  -H "Authorization: Bearer sk-bl-..." \
  -H "Content-Type: application/json" \
  -d '{"allowedModels": ["openai/*", "anthropic/claude-sonnet-4.6"]}'

Circuit Breaker (สวิตช์ฆ่าการใช้จ่าย)

ระบบ spend cap แบบ dual-window ที่จะบล็อก request ถัดไปเมื่อค่าใช้จ่าย upstream พุ่งสูงผิดปกติ ออกแบบมาเพื่อจำกัด script ที่ run หลุด, infinite loop, หรือ key ที่ถูกขโมยไปใช้ ก่อนที่จะเสียเงินจริง

หลักการทำงาน

• มี window คงที่สองช่วงที่ track ใน Redis ต่อ scope: ค่าใช้จ่าย upstream (USD) ใน 1 นาที และ 1 ชั่วโมง
• ถ้าช่วงใดช่วงหนึ่งถึง threshold, request ถัดไปทั้งหมดใน scope นั้นจะถูกปฏิเสธจนกว่า window จะรีเซ็ต
• ค่า default: $5 / นาที, $20 / ชั่วโมง ปิดใช้งานโดย default — ต้องเปิดใช้งานเอง
• Counter อยู่ใน Redis พร้อม TTL — recovery เป็นแบบอัตโนมัติ ไม่ต้อง reset เองสำหรับ trip ระดับ org/team/member

Scopes (member override team override org)

แต่ละชั้นตั้ง threshold ของตนเองได้ ลำดับการ resolve คือ member → team → org → platform default — ค่าแรกที่ไม่ใช่ null ชนะในแต่ละ field (cbEnabled, cbMinuteUsd, cbHourlyUsd)

• ระดับ Org — มีผลกับทุก key ภายใต้ organization ตั้งค่าใน Org Portal → Circuit Breaker
• ระดับ Team — มีผลกับทุก key ที่ tag กับทีมนั้น Override org สำหรับ key เหล่านั้น
• ระดับ Member — มีผลเฉพาะ key ที่ tag กับ member นั้น Override ทั้ง team และ org

พฤติกรรมเมื่อ trip

เมื่อ trip request จะ fail ทันที (ไม่มีการเรียก upstream) Response เป็น HTTP 429 พร้อม body แบบนี้:

HTTP/1.1 429 Too Many Requests
Content-Type: application/json

{
  "error": {
    "message": "Spend circuit breaker tripped at member scope (minute window: $5.2341 ≥ $5.00). Try again later or contact your organization owner."
  }
}

บันทึกการตรวจสอบ

ทุก trip event และทุกการเปลี่ยน config จะถูกบันทึก:

• Trip events — action org.cb.tripped / team.cb.tripped / org_member.cb.tripped Dedup เป็น 1 entry ต่อ scope+window ต่อชั่วโมง เพื่อไม่ให้ trip ที่ค้างนาน flood log
• Config changes — action org.cb.update / team.cb.update / org_member.cb.update บันทึกค่าก่อน/หลัง พร้อม actor

การจัดการ API

Org admin อ่านและอัปเดต settings ผ่าน API ได้ ทุก endpoint รองรับ Web Session หรือ Bearer Management Key (sk-bl-...) ส่ง field กลุ่มใดก็ได้ใน PATCH body; null จะล้าง field และ fallback ไปยังชั้นแม่

# Org-level config
GET    /api/orgs/:orgId/circuit-breaker
PATCH  /api/orgs/:orgId/circuit-breaker

# Team-level config
GET    /api/orgs/:orgId/teams/:teamId/circuit-breaker
PATCH  /api/orgs/:orgId/teams/:teamId/circuit-breaker

# Member-level config
GET    /api/orgs/:orgId/members/:memberId/circuit-breaker
PATCH  /api/orgs/:orgId/members/:memberId/circuit-breaker

# Example: tighten the org-level cap to $2/min, $10/hr
curl -X PATCH https://bazaarlink.ai/api/orgs/$ORG_ID/circuit-breaker \
  -H "Authorization: Bearer sk-bl-..." \
  -H "Content-Type: application/json" \
  -d '{"cbMinuteUsd": 2, "cbHourlyUsd": 10, "cbEnabled": true}'

# GET response (org scope)
{
  "settings":         { "cbEnabled": true, "cbMinuteUsd": 2,  "cbHourlyUsd": 10  },
  "resolvedSettings": { "cbEnabled": true, "cbMinuteUsd": 2,  "cbHourlyUsd": 10  },
  "liveSpend":        { "minuteSpend": 0.4123, "hourSpend": 3.8721 }
}

API การหมุนปุ่ม

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

ขั้นตอนการหมุน

1. สร้างคีย์ API ใหม่
2. อัปเดตแอปพลิเคชันหรือตัวแปรสภาพแวดล้อมของคุณให้ใช้คีย์ใหม่
3. ตรวจสอบว่าคีย์ใหม่ทำงานอย่างถูกต้อง
4. ปิดการใช้งานหรือลบคีย์เก่า

# Key CRUD via Bearer auth requires a MANAGEMENT key (keyType: "management").
# Standard keys get 403 on /v1/keys — create a management key first,
# or rotate keys from the dashboard UI instead.

# Step 1: Create new key (management key auth)
POST https://api.bazaarlink.ai/v1/keys
Authorization: Bearer $BL_MANAGEMENT_KEY
{"name": "Production v2"}
# → saves new key: sk-bl-NEW_KEY_VALUE

# Step 2: Update your application
# export BAZAARLINK_API_KEY=sk-bl-NEW_KEY_VALUE

# Step 3: Verify new key works
curl https://api.bazaarlink.ai/v1/models \
  -H "Authorization: Bearer sk-bl-NEW_KEY_VALUE"

# Step 4: Revoke old key (management key auth again)
DELETE https://api.bazaarlink.ai/v1/keys/:old_key_id
Authorization: Bearer $BL_MANAGEMENT_KEY

ส่งออกกิจกรรม

ดาวน์โหลดประวัติการใช้งาน API ทั้งหมดของคุณเป็น CSV สำหรับการตรวจสอบทางการเงิน การวิเคราะห์ต้นทุน หรือการรายงานการปฏิบัติตามข้อกำหนด

CSV ส่งออก

เข้าสู่ระบบและไปที่หน้าบันทึก คลิกปุ่มส่งออก CSV ที่มุมขวาบนเพื่อดาวน์โหลดประวัติทั้งหมดของคุณเป็นไฟล์ CSV ไม่จำเป็นต้องโทร API

CSV คอลัมน์

JSON การใช้งาน API

สำหรับการเข้าถึงแบบเป็นโปรแกรม ให้ค้นหาสถิติรวมที่จัดกลุ่มตามช่วงเวลา รุ่น หรือคีย์:

# Query usage data (grouped / aggregated)
GET https://api.bazaarlink.ai/v1/usage
Authorization: Bearer sk-bl-YOUR_KEY

# With period filtering (day | week | month | year)
GET https://api.bazaarlink.ai/v1/usage?period=month

# Response
{
  "period": "month",
  "since": "2025-01-01T00:00:00.000Z",
  "credits": 10.5000,
  "totals": {
    "spend": 0.1812,
    "requests": 309,
    "tokens": 161200,
    "promptTokens": 95000,
    "completionTokens": 66200
  },
  "byModel": [{ "model": "openai/gpt-4o", "spend": 0.0028, "tokens": 1200, "requests": 5 }],
  "byKey":   [{ "keyName": "My Agent", "spend": 0.0028, "tokens": 1200, "requests": 5 }],
  "byApp":   [{ "appName": "MyApp", "spend": 0.0015, "tokens": 600, "requests": 3 }],
  "timeSeries": [{ "date": "2025-01-15", "model": "openai/gpt-4o", "cost": 0.0012, "tokens": 500, "requests": 2 }]
}

การบัญชีการใช้งาน

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

การอ้างอิงฟิลด์การตอบสนอง

import httpx

# Aggregated stats (Bearer token — period: day | week | month | year)
response = httpx.get(
    "https://api.bazaarlink.ai/v1/usage",
    headers={"Authorization": "Bearer sk-bl-YOUR_KEY"},
    params={"period": "month"},
)

data = response.json()
totals = data["totals"]
print("This month: US$%.4f  (%d requests)" % (totals["spend"], totals["requests"]))

# Cost breakdown by model
for m in data["byModel"]:
    print("  %s: US$%.4f  (%d reqs, %d tokens)" % (m["model"], m["spend"], m["requests"], m["tokens"]))

รายงานคำติชม

ช่วยเราปรับปรุง BazaarLink โดยการรายงานปัญหา ข้อบกพร่อง หรือข้อเสนอแนะ เราติดตามทุกช่องทางข้อเสนอแนะอย่างกระตือรือร้น

วิธีการรายงาน

สิ่งที่ต้องรวม

• Request ID (จากฟิลด์รหัสการตอบกลับ)
• รุ่นที่ใช้และส่งพารามิเตอร์แล้ว
• Expected เทียบกับพฤติกรรมจริง
• การประทับเวลาและความถี่ของปัญหา
• Error ข้อความหรือรหัสสถานะ HTTP

ไปที่หน้าติดต่อของเราเพื่อส่งข้อเสนอแนะ

คำถามที่พบบ่อย