เอกสาร BazaarLink

ราคา

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

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

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

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

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

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

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

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

หากคำขอเสร็จสมบูรณ์ตามปกติและผู้ให้บริการส่ง usage ที่ถูกต้อง BazaarLink จะคิดค่าบริการตาม usage นั้น อย่าตัดสินว่าฟรีจาก output tokens เพียงอย่างเดียว เพราะแม้ output tokens จะเป็น 0 ก็ยังอาจมีค่า input tokens หรือต้นทุน upstream ที่รายงานอย่างถูกต้อง โปรดตรวจสอบ usage.cost หรือบันทึก Activity สำหรับยอดสุดท้าย

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

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

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

Base URL

https://bazaarlink.ai/api/v1

ใช้ OpenAI SDK

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

from openai import OpenAI

client = OpenAI(
    base_url="https://bazaarlink.ai/api/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 ของผู้ให้บริการ upstream ของคุณเอง (อินเทอร์เฟซที่เข้ากันได้กับ OpenAI หรือ Anthropic) เข้ากับบัญชีส่วนตัวหรือองค์กร — คำขอที่เข้าเงื่อนไขจะเชื่อมต่อ upstream ผ่านคีย์ของคุณโดยตรง เลือกโหมด fallback ได้ทั้งแบบ seamless และ strict คีย์ส่วนตัวจัดการที่แท็บ BYOK ในหน้าคีย์ ส่วนองค์กรจัดการในตั้งค่าองค์กร ไปที่การตั้งค่า BYOK →

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

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

ย้ายจาก OpenRouter

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

1. ฐาน URL: https://openrouter.ai/api/v1 → https://bazaarlink.ai/api/v1
2. คีย์ API: sk-or-... → sk-bl-... (สร้างได้ที่ /keys)
3. Model ID: ใช้รูปแบบ provider/model เดียวกัน (เช่น anthropic/claude-sonnet-4.6) ดูแคตตาล็อกทั้งหมดที่ GET /api/v1/models
4. fallback ผ่าน models[], การตั้งค่า routing ผู้ให้บริการ, 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://bazaarlink.ai/api/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. ความพร้อมใช้งานสูง

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

มัลติโมดัล

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

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

ตัวอย่าง:

# Image — URL or base64 data URI
curl https://bazaarlink.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"google/gemini-2.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://bazaarlink.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"google/gemini-2.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://bazaarlink.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"google/gemini-2.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://bazaarlink.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"google/gemini-2.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://bazaarlink.ai/api/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 ที่สำเร็จจะมี rate limit headers สำหรับให้ client ติดตามได้:

X-RateLimit-Limit: 200        # Max requests per minute for your tier
X-RateLimit-Remaining: 198    # Remaining requests in current window
X-RateLimit-Reset: 1740000060 # Unix timestamp when the window resets
X-Request-Id: chatcmpl-abc123 # Unique request ID for debugging

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

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

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

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

การสร้างภาพ

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

curl -N https://bazaarlink.ai/api/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://bazaarlink.ai/api/v1/videos \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"alibaba/wan2.7-t2v","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-2.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 ฉบับเต็ม →

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

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

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

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

List คีย์

GET https://bazaarlink.ai/api/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://bazaarlink.ai/api/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://bazaarlink.ai/api/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://bazaarlink.ai/api/v1/keys/:id
Authorization: Bearer sk-bl-YOUR_MGMT_KEY

# Returns 204 No Content on success

Query ยอดคงเหลือ

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

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

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

GET https://bazaarlink.ai/api/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://bazaarlink.ai/api/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 รูปแบบการตอบสนอง

ปลายทางการอนุมานโมเดลจะส่งคืนซองข้อผิดพลาดที่เข้ากันได้กับ OpenAI โดยฟิลด์ type อาจแตกต่างหรือถูกละไว้ได้ โปรดใช้สถานะ HTTP และ error.code ในตรรกะโปรแกรมแทนการแยกวิเคราะห์ข้อความ

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

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

Before streaming, the HTTP status identifies the broad failure class. error.code is either that number or a stable string for a specific remedy. Prefer the string code when present, otherwise use the HTTP status.

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

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.

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

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

Compatibility note: rate-limit and emergency-brake paths currently emit numeric error.code values. Use HTTP status, Retry-After, and the documented response 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://bazaarlink.ai/api/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-4.1",
            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

After a stream starts, the HTTP response is already 200. Parse each SSE data frame and treat a top-level error or choices[0].finish_reason === "error" as a failed, incomplete response.

หากสตรีมล้มเหลวกลางทาง BazaarLink จะส่ง event SSE สุดท้ายที่มีอ็อบเจ็กต์ error ระดับบนสุด ตามด้วย data: [DONE] ส่วน chunk ที่ถูกส่งต่อจาก upstream บางรายแบบไม่แก้ไข อาจใส่ข้อผิดพลาดไว้ที่ choice แทน (choices[0].finish_reason === "error") — ให้รองรับทั้งสองแบบ

// If the stream fails mid-flight, BazaarLink emits a final SSE event
// with a top-level "error" object, followed by data: [DONE]
data: {"error":{"message":"Upstream stream interrupted. The response is incomplete.","type":"upstream_error","code":502}}

data: [DONE]

// Chunks relayed verbatim from some upstreams may instead carry the error
// inline on the choice: choices[0].finish_reason === "error" with an
// "error" object ({ code, message }) on the choice — handle both shapes.
// 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://bazaarlink.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4.1",
    "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-4.1",
        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-4.1",
    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-4.1",
        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://bazaarlink.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4.1",
    "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://bazaarlink.ai/api/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..."

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

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

การใช้งาน

// Enable middle-out on any model
{
  "model": "openai/gpt-4.1",
  "transforms": ["middle-out"],
  "messages": [
    { "role": "system", "content": "You are a helpful assistant." },
    ... // long conversation — middle will be trimmed to fit context
  ]
}

// Disable auto-trimming for small-context models
{ "transforms": [] }

ประเภทการแปลง

พฤติกรรมเริ่มต้น

โมเดลที่มีบริบท ≤8k จะเปิดใช้งานตรงกลางออกโดยอัตโนมัติ สำหรับโมเดลบริบทที่ใหญ่ขึ้น ให้เลือกอย่างชัดเจน โมเดล Anthropic Claude ยังบังคับใช้ขีดจำกัด 1,000 ข้อความโดยอัตโนมัติ โดยไม่คำนึงถึงการตั้งค่าการแปลง

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-4.1",
    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/o3-mini",
  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-32b",
    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 o3 — specify effort level
const response2 = await client.chat.completions.create({
  model: "openai/o3",
  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 },
});

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

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

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

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

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

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

import time

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

stream = client.chat.completions.create(
    model="google/gemini-2.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://bazaarlink.ai/api/v1/generation?id=chatcmpl-abc123" \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY"

# Response
{
  "data": {
    "id": "chatcmpl-abc123",
    "model": "google/gemini-2.5-flash",
    "duration_ms": 842,
    "throughput": 61.2,
    "usage": { "prompt_tokens": 12, "completion_tokens": 48, "total_tokens": 60 }
  }
}

# Use provider.sort for automatic latency optimization
response = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={
        "provider": {
            "sort": "latency",  # Always pick lowest-latency provider
        }
    },
)

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

BazaarLink เพิ่มความพร้อมใช้งานของ API ให้สูงสุดผ่านหลายเลเยอร์: การเฟลโอเวอร์อัตโนมัติ เซอร์กิตเบรกเกอร์ และการตรวจสอบสถานภาพของผู้ให้บริการ

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

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

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

# BazaarLink handles failover automatically — no code changes needed.
# Configure fallback models for maximum resilience:

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

# Check if failover was used (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://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

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

เมื่อคำขอมาถึง /api/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-v3.2

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

เมื่อคุณส่งคำขอ 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://bazaarlink.ai/api/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 เป็นเพียงชื่อแทนเสริม (เติมให้โมเดลเสียเงินไม่ทำให้ฟรี)

รุ่นต่างๆ

เพิ่มคำต่อท้ายให้กับรหัสโมเดลใดๆ เพื่อเปลี่ยนพฤติกรรมการกำหนดเส้นทาง BazaarLink รองรับ 7 ประเภทตัวแปร ขณะนี้รองรับตัวแปรรุ่น

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

ตัวแปรเหล่านี้มีอยู่เป็นรุ่นที่แยกจากกันโดยมีราคาและความสามารถของตัวเอง BazaarLink ลองใช้ ID โมเดลแบบเต็ม (พร้อมส่วนต่อท้าย) ก่อน จากนั้นจึงถอยกลับไปเป็นโมเดลพื้นฐาน

:free
:extended
:thinking
:exacto

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

ส่วนต่อท้ายเหล่านี้แก้ไขการเลือกผู้ให้บริการโดยไม่ต้องเปลี่ยนเอกลักษณ์ของโมเดล ส่วนต่อท้ายจะถูกถอดออกก่อนเส้นทางที่ตรงกัน

:floor   # lowest listed input price first
:nitro   # throughput-oriented shortcut
:online  # enable web-search routing

พฤติกรรมของผู้ให้บริการหลายราย

สำหรับอัปสตรีมที่รองรับตัวแปรต่างๆ ส่วนต่อท้ายจะถูกส่งผ่านตามที่เป็น สำหรับผู้ให้บริการโดยตรง (เช่น direct OpenAI, Fireworks) ส่วนต่อท้ายจะถูกตัดออก และ BazaarLink จะจัดการการกำหนดเส้นทางในเครื่อง

โมเดลฟรี

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

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

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

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

deepseek/deepseek-v4-flash

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

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

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

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

# 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, billing, change logs, and security logs
• Education sessions and quotas for eligible organizations
• แผนสถาบัน: องค์กรการศึกษาสามารถจัดการเซสชันและโควต้าของนักเรียนเพิ่มเติมได้

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

# Create a team
curl https://bazaarlink.ai/api/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://bazaarlink.ai/api/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://bazaarlink.ai/api/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 เป็นประจำเป็นวิธีปฏิบัติที่ดีที่สุดด้านความปลอดภัย BazaarLink รองรับการหมุนเวียนคีย์แบบ Zero-downtime — สร้างคีย์ใหม่ก่อน จากนั้นจึงย้าย จากนั้นเพิกถอนคีย์เก่า คุณสามารถเพิกถอนคีย์

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

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

# Key CRUD via Bearer auth requires a MANAGEMENT key (keyType: "management").
# Standard keys get 403 on /api/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://bazaarlink.ai/api/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://bazaarlink.ai/api/v1/models \
  -H "Authorization: Bearer sk-bl-NEW_KEY_VALUE"

# Step 4: Revoke old key (management key auth again)
DELETE https://bazaarlink.ai/api/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://bazaarlink.ai/api/v1/usage
Authorization: Bearer sk-bl-YOUR_KEY

# With period filtering (day | week | month | year)
GET https://bazaarlink.ai/api/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://bazaarlink.ai/api/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"]))

แผนสถาบัน

Institution Plan ช่วยให้สถาบันใดก็ตาม (โรงเรียน บริษัท การประชุม หน่วยงานรัฐ ฯลฯ) ออก session token อายุสั้นให้สมาชิกจาก key ระดับองค์กรเพียงตัวเดียว สมาชิกไม่จำเป็นต้องสร้างบัญชีบนแพลตฟอร์ม องค์กรเป็นผู้ควบคุมว่าสมาชิกคนใดสามารถขอ token ได้โดยอิงจากโดเมนอีเมล (เช่น nthu.edu.tw) การใช้งานทั้งหมดจะถูกเรียกเก็บเงินจากบัญชีขององค์กร หน้านี้ใช้สถานการณ์การศึกษาเป็นตัวอย่าง — กลไกเดียวกันใช้ได้กับสถาบันใดก็ตามที่ต้องการการเข้าถึงชั่วคราวระยะสั้นสำหรับผู้ใช้หลายคน

ภาพรวมสถาปัตยกรรม

• รหัสสถาบัน — ขึ้นต้นด้วย sk-edu- สร้างโดย org_admin บนหน้า keys ขององค์กร ไม่สามารถใช้เป็น Bearer token เรียก API โดยตรง — การเรียกตรงจะได้ 403
• โทเค็นเซสชันสมาชิก — ขึ้นต้นด้วย edu-sess- นักเรียนได้รับหลังจากยืนยันอีเมล อายุการใช้งานเริ่มต้น 24 ชั่วโมง สามารถเพิกถอนได้โดย admin ขององค์กร
• โดเมนที่อนุญาต — องค์กรกำหนดว่าโดเมนอีเมลใดบ้าง (จับคู่แบบตรงตัว ไม่มีการ bypass ด้วย suffix) ที่สามารถขอ session ได้
• Usage การแสดงที่มา — คำขอจากนักเรียนทั้งหมดถูกเรียกเก็บเงินจากบัญชีขององค์กร สามารถดูการใช้งานต่อ session และต่ออีเมลได้ในแดชบอร์ดขององค์กร

ขั้นที่ 1 — Platform admin ตั้งประเภทองค์กรเป็น Education

จาก sales@bazaarlink.ai / support@bazaarlink.ai ค้นหาองค์กรเป้าหมาย สลับไปแท็บ "Org Type" เลือก Education และตั้งโดเมนอีเมลที่อนุญาต:

{
  "orgType": "education",
  "eduConfig": {
    "allowedDomains": ["nthu.edu.tw", "student.nthu.edu.tw"],
    "sessionTtlSeconds": 86400,
    "verificationTtlSeconds": 900,
    "maxSessionsPerEmailPerKey": 5
  }
}

ขั้นที่ 2 — Org admin สร้าง Institution Key

บนหน้า API Keys ขององค์กร เลือก "Education" เป็นประเภท key เมื่อสร้าง key ใหม่ ระบบจะสร้าง key รูปแบบ sk-edu-... และแสดงเพียงครั้งเดียว — บันทึกไว้และส่งต่อให้นักเรียนขององค์กรนั้นผ่านช่องทางทางการของคุณ

ขั้นที่ 3 — นักเรียนขอรหัสยืนยัน

นักเรียนเข้าไปที่ /access และกรอก edu key + อีเมลโรงเรียน หรือเรียก API โดยตรง:

curl -X POST https://bazaarlink.ai/api/edu/request-code \
  -H "Content-Type: application/json" \
  -d '{
    "key": "sk-edu-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
    "email": "alice@nthu.edu.tw"
  }'

# Success (incl. unknown key/email — enumeration defence) → {"ok":true,"sent":true}
# Rate limit / resend cooldown → 429 {"error":"rate_limited"} or {"error":"cooldown"}
# Sends a 6-digit verification code to the email; default 15-minute lifetime

ขั้นที่ 4 — นักเรียนส่งรหัสเพื่อแลกเป็น session token

curl -X POST https://bazaarlink.ai/api/edu/verify \
  -H "Content-Type: application/json" \
  -d '{
    "key":   "sk-edu-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
    "email": "alice@nthu.edu.tw",
    "code":  "646291"
  }'

# Success → 200
{
  "token":     "edu-sess-827d11a1ec67d175cfd4f67f929261f4",
  "expiresAt": "2026-05-04T11:16:00.163Z",
  "organization": { "id": "...", "name": "NTHU AI Lab" }
}

# Wrong code → 400 {"error":"invalid"}
# 5 wrong attempts → 429 {"error":"too_many_attempts"} (code invalidated; re-request)

ขั้นที่ 5 — ใช้ session token เรียก API

ใช้ token รูปแบบ edu-sess-... เป็น Bearer token เพื่อเรียก endpoint ใด ๆ ของ chat / completions / embeddings:

curl -X POST https://bazaarlink.ai/api/v1/chat/completions \
  -H "Authorization: Bearer edu-sess-827d11a1ec67d175cfd4f67f929261f4" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-haiku-4.5",
    "messages": [{"role": "user", "content": "Hello"}]
  }'

แดชบอร์ดองค์กร — การติดตามและการเพิกถอน

องค์กรประเภท Education จะได้รับแท็บ Education ใน side nav ซึ่งให้บริการ:

• การตั้งค่า — ปรับโดเมนที่อนุญาต, TTL, จำนวน session สูงสุดต่ออีเมลต่อ key และโควต้าต่อ session ทั้งจำนวน request / token / USD
• เซสชัน — แสดงรายการ session ที่ยัง active / หมดอายุ / ถูกเพิกถอนทั้งหมด กรองตามอีเมล เพิกถอน session แต่ละรายการได้
• สถิติการใช้งาน — จำนวนการเรียกต่อ session การบริโภค token และค่าใช้จ่ายสะสม

ความปลอดภัยและขีดจำกัด

การเรียกเก็บเงินและการระบุการใช้งาน

คำขอทั้งหมดที่ทำผ่าน session token จะถูกเรียกเก็บ 100% จากองค์กรที่เป็นเจ้าของ edu key ซึ่งสอดคล้องกับวิธีที่ผู้ให้บริการต้นทาง (OpenAI / Anthropic / ฯลฯ) เรียกเก็บเงิน (ต่อ token) แดชบอร์ดขององค์กรรองรับการ drill-down ตาม session ตามอีเมล และตาม key

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

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

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

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

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

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

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