BazaarLink दस्तावेज़ीकरण

मूल्य निर्धारण

BazaarLink मूल्य मॉडल उपयोग शून्य मार्कअप पर (प्रत्येक प्रदाता की आधिकारिक सूची मूल्य के समान)। प्लेटफ़ॉर्म शुल्क टॉप-अप (जमा) पर लिया जाता है: एक 10% लेनदेन शुल्क, साथ ही 5% ताइवान VAT TWD चैनलों पर। TWD उद्धरण और इलेक्ट्रॉनिक एकीकृत चालान के साथ USD में बिल किया गया। सेल्फ-सर्व पे-एज़-यू-टॉप-अप; उद्यम मासिक बिलिंग (नेट-30, परक्राम्य) की व्यवस्था कर सकते हैं।

यह कैसे काम करता है

• उपभोग (डेबिट): प्रत्येक API कॉल को प्रदाता के आधिकारिक USD सूची मूल्य पर वास्तविक टोकन उपयोग द्वारा बिल किया जाता है, जो आपके शेष से काटा जाता है - शून्य मार्कअप, उपभोग पर कोई अतिरिक्त शुल्क नहीं।
• टॉप-अप (जमा): TWD को वास्तविक समय बिक्री दर पर USD में परिवर्तित किया जाता है और आपके शेष में जोड़ा जाता है; टॉप-अप पर 10% लेनदेन शुल्क लिया जाता है।
• • क्रेडिट कार्ड: एक अतिरिक्त US$0.60 फ्लैट शुल्क लागू होता है; एक रसीद जारी की जाती है.
• • TWD चैनल: 5% ताइवान VAT जोड़ा गया है और एक ताइवान इलेक्ट्रॉनिक एकीकृत चालान जारी किया गया है।
• • बैंक वायर ट्रांसफर: बड़े या एंटरप्राइज़ टॉप-अप के लिए, वायर ट्रांसफर और कस्टम इनवॉइसिंग की व्यवस्था करने के लिए हमसे संपर्क करें।
• इनवॉइसिंग: इलेक्ट्रॉनिक एकीकृत चालान ताइवान व्यय वर्कफ़्लो के लिए समर्थित हैं; खरीद या मासिक बिलिंग की आवश्यकता वाली कंपनियां उद्यम शर्तों (नेट-30, परक्राम्य) की व्यवस्था कर सकती हैं।

विनिमय दर के बारे में

विदेशी-विनिमय रूपांतरण वास्तविक समय दर का उपयोग करता है; मासिक बिलिंग बिलिंग (विवरण) समय पर दर का उपयोग करती है, जबकि प्रीपेड टॉप-अप टॉप-अप-टाइम दर पर परिवर्तित होते हैं। दर और टाइमस्टैम्प को बिलिंग रिकॉर्ड के साथ रखा जाता है।

विफल अनुरोधों के लिए बिलिंग सुरक्षा

यदि upstream अनुरोध बिना बिल योग्य usage के विफल होता है, तो BazaarLink आरक्षित पूरी राशि अपने-आप लौटा देता है। stream शुरू होने के बाद विफल होने पर भी उस प्रयास का शुल्क USD 0 रहता है।

0 output tokens का अर्थ हमेशा निःशुल्क नहीं है

यदि अनुरोध सामान्य रूप से पूरा होता है और प्रदाता वैध usage लौटाता है, तो BazaarLink उसी usage का निपटान करता है। केवल output tokens देखकर निःशुल्क न मानें: 0 output tokens के साथ भी input tokens या वैध upstream-reported cost का शुल्क लग सकता है। अंतिम शुल्क के लिए usage.cost या Activity रिकॉर्ड देखें।

क्विक स्टार्ट

इंटीग्रेट करने के तीन तरीके

5 मिनट से कम समय में आरंभ करें। BazaarLink OpenAI SDK के साथ पूरी तरह से संगत है - बस इसे बदलें

Base URL

https://bazaarlink.ai/api/v1

OpenAI SDK का उपयोग करना

BazaarLink OpenAI SDK के साथ पूरी तरह से संगत है। बस आधार 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 कुंजियाँ (OpenAI या Anthropic संगत इंटरफ़ेस) अपने खाते या संगठन से जोड़ें — योग्य अनुरोध आपकी कुंजी से सीधे अपस्ट्रीम जाते हैं, seamless या strict फ़ॉलबैक मोड के विकल्प के साथ। व्यक्तिगत कुंजियाँ कुंजी पृष्ठ के BYOK टैब में, संगठन अपनी कुंजियाँ संगठन सेटिंग्स में प्रबंधित करते हैं। BYOK सेटिंग्स पर जाएँ →

सामग्री फ़िल्टरिंग

आपके API ट्रैफ़िक के लिए दोतरफ़ा सामग्री सुरक्षा: प्रॉम्प्ट इंजेक्शन वाले अनुरोध ब्लॉक (400) होते हैं, और अनुरोध व प्रतिक्रिया में संवेदनशील डेटा (API कुंजियाँ, कार्ड नंबर, पहचान संख्याएँ आदि) अपने आप छिपा दिया जाता है। नियम और छूट सूची अनुकूलन योग्य हैं, उपयोग आँकड़े भी उपलब्ध हैं। सामग्री फ़िल्टर सेटिंग्स पर जाएँ →

OpenRouter से माइग्रेट करें

BazaarLink का API OpenRouter-संगत है — अधिकांश इंटीग्रेशन केवल दो मान बदलकर स्विच हो जाते हैं: base URL को https://bazaarlink.ai/api/v1 और API key को sk-bl- से शुरू होने वाली BazaarLink key से।

1. आधार URL: https://openrouter.ai/api/v1 → https://bazaarlink.ai/api/v1
2. API key: sk-or-... → sk-bl-... (/keys पर एक बनाएँ)
3. मॉडल ID: वही provider/model फॉर्मेट (जैसे anthropic/claude-sonnet-4.6); पूरा कैटलॉग GET /api/v1/models पर
4. models[] फ़ॉलबैक, प्रोवाइडर राउटिंग प्राथमिकताएँ, स्ट्रीमिंग, टूल कॉलिंग और स्ट्रक्चर्ड आउटपुट समान अनुरोध स्वरूप का उपयोग करते हैं

  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 अनुरोधों के लिए आपकी API कुंजी के साथ एक प्राधिकरण हेडर की आवश्यकता होती है।

Authorization: Bearer sk-bl-YOUR_API_KEY

से अपनी API कुंजी प्राप्त करें डैशबोर्ड. अपनी कुंजी सुरक्षित रखें - इसे क्लाइंट-साइड कोड में उजागर न करें।

वैकल्पिक शीर्षलेख

सिद्धांत

BazaarLink को तीन मुख्य सिद्धांतों के आधार पर डिज़ाइन किया गया है:

1. एकीकृत इंटरफ़ेस

One API, एक SDK, सैकड़ों मॉडल। अपना कोड बदले बिना OpenAI, Anthropic, Google मिथुन, मेटा लामा और अन्य के बीच स्विच करें - बस मॉडल आईडी बदलें।

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 (एनिमेटेड सहित)। आप एक ही संदेश में एकाधिक छवियां शामिल कर सकते हैं - प्रत्येक एक अलग छवि_यूआरएल भाग के रूप में:

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 में दो स्वतंत्र सीमाएँ लागू होती हैं: requests per minute पर rate limit, और account spending पर credit limit। Rate limit पार होने पर HTTP 429 मिलता है; credits खत्म होने पर HTTP 402 मिलता है।

दर सीमा

Rate सीमाएं प्रति उपयोगकर्ता (प्रति कुंजी नहीं) हैं, प्रति मिनट अनुरोधों में मापी जाती हैं (RPM)। कोई दैनिक सीमा नहीं है. टियर आपके खाते के क्रेडिट बैलेंस द्वारा स्वचालित रूप से निर्धारित होता है।

जब दर सीमा पार हो जाती है तो आपको रिट्री-आफ्टर हेडर के साथ 429 प्रतिक्रिया प्राप्त होती है। अनुरोधों को पुनः प्रयास करते समय घातीय बैकऑफ़ लागू करें।

रिस्पॉन्स हेडर

हर successful response में client-side tracking के लिए rate limit headers शामिल होते हैं:

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 response का मतलब है कि आपका account balance या key की spending cap शून्य पर पहुँच गई है — न कि आप बहुत तेज़ requests भेज रहे हैं। इन responses में rate limit headers नहीं होते, और अगर limit streaming के बीच में लगे तो HTTP status बदलने की बजाय SSE error event मिलेगा।

व्यक्तिगत सर्किट ब्रेकर

आपकी सभी API कुंजियों पर लागू होने वाली 1 मिनट और 1 घंटे की स्थिर (fixed) USD खर्च सीमा। जब विंडो की सीमा पार हो जाए तो नए अनुरोधों को HTTP 429 मिलता है; विंडो clock boundary पर स्वतः रीसेट हो जाती है।

Image जनरेशन

modalities:["image"] के साथ /v1/chat/completions या OpenAI DALL·E-संगत /v1/images/generations से इमेज जनरेट करें।

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 रेफ़रेंस में देखें →

वीडियो जनरेशन

असिंक्रोनस 3-चरण फ़्लो (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" }

पूरा फ़्लो (पोलिंग, डाउनलोड, टास्क प्रकार, चेतावनियाँ) API रेफ़रेंस में देखें →

PDF इनपुट

PDF को नेटिव रूप से सपोर्ट करने वाले मॉडल (जैसे Claude, Gemini) को संदेशों में सीधे PDF दस्तावेज़ भेजें। BazaarLink फ़ाइल को सीधे मॉडल को भेजता है — सामान्य input tokens की तरह बिल होता है, कोई अतिरिक्त शुल्क या प्रोसेसिंग चरण नहीं।

समर्थित प्रारूप

• PDF दस्तावेज़ (पाठ, चित्र, तालिकाएँ, स्कैन किए गए)
• Base64-एन्कोडेड डेटा URL (`data:application/pdf;base64,...`)
• बहु-पृष्ठ दस्तावेज़ केवल
• पासवर्ड-मुक्त पीडीएफ

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 कुंजी

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

एक प्रबंधन कुंजी बनाना

पर जाएंप्रबंधन API कुंजी पृष्ठऔर "बनाएं" पर क्लिक करें - यह आपके मानक API कुंजियों से एक अलग पृष्ठ है, न कि उसी पृष्ठ पर एक प्रकार चयनकर्ता।

सूची कुंजियाँ

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
  }
}

Query उपयोग

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

# period: day | week | month | year

App एट्रिब्यूशन

उपयोग ट्रैकिंग, डैशबोर्ड दृश्यता और सूक्ष्म विश्लेषण सक्षम करने के लिए अनुरोध हेडर में अपने एप्लिकेशन की पहचान करें।

उपलब्ध हेडर

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!"}],
)

त्रुटि कोड

त्रुटि प्रतिक्रिया प्रारूप

मॉडल इन्फ़रेंस एंडपॉइंट 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)

स्ट्रीमिंग त्रुटि प्रारूप

त्रुटियां जो किसी भी टोकन को स्ट्रीम करने से पहले होती हैं, JSON बॉडी के साथ एक मानक HTTP त्रुटि प्रतिक्रिया लौटाती हैं।

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 एक अंतिम SSE इवेंट भेजता है जिसमें टॉप-लेवल error ऑब्जेक्ट होता है, उसके बाद data: [DONE] आता है। कुछ 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.

टूल कॉलिंग

टूल कॉलिंग (जिसे फ़ंक्शन कॉलिंग के रूप में भी जाना जाता है) मॉडल को आपके द्वारा परिभाषित बाहरी फ़ंक्शन को लागू करने देता है। मॉडल तय करता है कि टूल को कब कॉल करना है और संरचित तर्क उत्पन्न करता है - आपका कोड फ़ंक्शन निष्पादित करता है और बातचीत जारी रखने के लिए परिणाम लौटाता है।

समर्थित मॉडल

अधिकांश फ्रंटियर मॉडल टूल कॉलिंग का समर्थन करते हैं। यहां कुछ लोकप्रिय विकल्प दिए गए हैं:

परिभाषित उपकरण

प्रत्येक उपकरण एक JSON ऑब्जेक्ट है जो एक फ़ंक्शन का वर्णन करता है जिसे मॉडल कॉल कर सकता है। पैरामीटर फ़ील्ड JSON स्कीमा का उपयोग करता है।

tool_choice विकल्प

पूर्ण प्रवाह

टूल कॉलिंग एक बहु-मोड़ प्रक्रिया है: (1) टूल के साथ अनुरोध भेजें → (2) मॉडल टूल_कॉल लौटाता है → (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.

समानांतर टूल कॉल

कुछ मॉडल एक ही प्रतिक्रिया में एकाधिक टूल को कॉल कर सकते हैं। प्रत्येक टूल कॉल को संभालें और सभी परिणाम लौटाएँ:

# 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)

Streaming के दौरान Tool Calls

Streaming में tool calls position के अनुसार indexed partial deltas में आते हैं — हर delta का argument string index के हिसाब से जोड़ते जाएं, जब तक finish_reason "tool_calls" न बन जाए, जो call पूरा होने का संकेत है।

# 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 Loop

जब तक model tools माँगता रहे तब तक call करते रहने और final answer मिलते ही रुक जाने वाला generic pattern — infinite loop रोकने के लिए 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)

Function Definition की Best Practices

• specific, descriptive names इस्तेमाल करें — सिर्फ weather नहीं, get_weather_forecast जैसा।
• function क्या करता है और कब इस्तेमाल करना है यह साफ description में लिखें — model सिर्फ इसी text के आधार पर call करने का फैसला करता है।
• जहाँ हो सके enum से values सीमित करें और description में example दें ताकि गलत arguments बनने की संभावना कम हो।
• सिर्फ वाकई जरूरी fields को required बनाएं, optional fields सच में छोड़े जा सकने योग्य होने चाहिए।

संरचित आउटपुट

मॉडल को स्कीमा से मेल खाते हुए वैध JSON वापस करने के लिए बाध्य करें। विश्वसनीय अनुप्रयोगों के निर्माण के लिए यह आवश्यक है जो मॉडल आउटपुट को प्रोग्रामेटिक रूप से पार्स करता है।

विधि 1: प्रतिक्रिया_प्रारूप (JSON स्कीमा)

सख्त JSON स्कीमा अनुपालन लागू करने के लिए:

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
        }
      }
    }
  }'

टिप्स

• स्पष्ट, वर्णनात्मक संपत्ति नामों का उपयोग करें - मॉडल उन्हें संदर्भ के रूप में उपयोग करता है।
• मॉडल का मार्गदर्शन करने के लिए स्कीमा गुणों में विवरण जोड़ें।
• Set सख्त: गारंटीकृत स्कीमा अनुपालन के लिए सही (विलंबता को थोड़ा बढ़ा सकता है)।
• स्कीमा को सरल रखें - गहराई से नेस्टेड स्कीमा आउटपुट गुणवत्ता को कम कर सकते हैं।
• विभिन्न मॉडलों के साथ परीक्षण - कुछ दूसरों की तुलना में जटिल स्कीमा को बेहतर ढंग से संभालते हैं।

असिस्टेंट प्रीफ़िल

संगत मॉडल रूट पर आगे का उत्तर माँगने के लिए messages ऐरे के अंत में एक अधूरा 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..."

मैसेज ट्रांसफॉर्म

संदेशों को मॉडल संदर्भ सीमाओं के भीतर फिट करने के लिए स्वचालित रूप से रूपांतरित करें। जब आपके संदेश किसी मॉडल की संदर्भ विंडो से अधिक हो जाते हैं, तो बीच से संदेशों को हटाकर बुद्धिमानी से वार्तालाप को संक्षिप्त करता है।

Usage

// 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 आपके संदेश सामग्री को डिफ़ॉल्ट रूप से संग्रहीत नहीं करता है। यह पृष्ठ बताता है कि आपका डेटा कैसे प्रबंधित किया जाता है। संवेदनशील डेटा संसाधित करने वाले अनुप्रयोगों के लिए उपयुक्त।

वर्तमान डेटा हैंडलिंग

• संदेश सामग्री: डिफ़ॉल्ट रूप से संग्रहीत नहीं, प्रसंस्करण के बाद मेमोरी से हटा दी गई
• बिलिंग मेटाडेटा: टोकन गिनती, टाइमस्टैम्प, मॉडल आईडी
• Uउपयोग लॉग: केवल अनुरोध आँकड़े, कोई संदेश सामग्री नहीं
• अपस्ट्रीम फ़ॉरवर्डिंग: अपस्ट्रीम प्रदाताओं को भेजे गए संदेश - उनकी गोपनीयता नीतियों के अधीन

प्रॉम्प्ट कैशिंग

प्रॉम्प्ट कैशिंग पहले से गणना किए गए शीघ्र टोकन का पुन: उपयोग करता है, जिससे लागत और विलंबता में काफी कमी आती है - विशेष रूप से बड़े, दोहराए गए सिस्टम संकेतों वाले अनुप्रयोगों के लिए।

यह कैसे काम करता है

कॉन्फ़िगरेशन की ज़रूरत है या नहीं, यह प्रोवाइडर पर निर्भर करता है। OpenAI परिवार के मॉडल लंबे, दोहराए गए प्रॉम्प्ट प्रीफ़िक्स को अपने-आप कैश कर लेते हैं — रिक्वेस्ट बदलने की ज़रूरत नहीं। Claude (Anthropic) मॉडल तभी कैश करते हैं जब रिक्वेस्ट में स्पष्ट cache_control ब्रेकपॉइंट हो; BazaarLink यह आपकी तरफ से नहीं जोड़ता, इसलिए बिना मार्कर वाली Claude रिक्वेस्ट कभी कैश नहीं होगी। BazaarLink आपके भेजे गए कैश मार्कर को जस-का-तस आगे भेजता है और 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)}")

रीज़निंग टोकन

रीज़निंग मॉडल (उदाहरण के लिए, डीपसीक आर1, ओ1 सीरीज़) अपना अंतिम उत्तर देने से पहले आंतरिक रूप से सोचते हैं। इन आंतरिक टोकन को रीज़निंग टोकन कहा जाता है और इन्हें अलग से बिल किया जाता है।

प्रतिक्रियाओं से रीजनिंग टोकन पढ़ना

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 },
});

विलंबता और प्रदर्शन

एआई API प्रतिक्रिया विलंबता को अनुकूलित करना उपयोगकर्ता अनुभव के लिए महत्वपूर्ण है। नीचे मुख्य कारक दिए गए हैं जो BazaarLink आर्किटेक्चर में विलंबता और अनुकूलन के लिए सर्वोत्तम प्रथाओं को प्रभावित करते हैं।

कारक जो विलंबता को प्रभावित करते हैं

• मॉडल का आकार: बड़े मॉडल (70B+) आमतौर पर उत्पन्न करने में धीमे होते हैं
• प्रदाता लोड: प्रदाताओं और दिन के समय के अनुसार भिन्न होता है
• टोकन गिनती: उच्च max_tokens का मतलब है पूरा होने में लंबा समय
• स्ट्रीमिंग बनाम नॉन-स्ट्रीमिंग: स्ट्रीम: ट्रू पहला टोकन तेजी से वितरित करता है
• Context लंबाई: बहुत लंबे संदर्भ प्री-प्रोसेसिंग समय को बढ़ाते हैं

अनुकूलन युक्तियाँ

• कथित विलंबता में सुधार के लिए स्ट्रीमिंग (स्ट्रीम: सत्य) को प्राथमिकता दें
• उच्च-थ्रूपुट प्रदाताओं का चयन करने के लिए :nitro वैरिएंट का उपयोग करें
• विलंबता-संवेदनशील परिदृश्यों के लिए छोटे मॉडल (flash/mini/haiku) चुनें
• provider.sort का उपयोग करें: स्वचालित रूप से सबसे कम-विलंबता प्रदाता का चयन करने के लिए "विलंबता"
• बार-बार अनुरोधों के लिए विलंबता को कम करने के लिए शीघ्र कैशिंग सक्षम करें

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 उपलब्धता को अधिकतम करता है: स्वचालित विफलता, सर्किट ब्रेकर, और प्रदाता स्वास्थ्य निगरानी।

उपलब्धता तंत्र

• सर्किट ब्रेकर: विफल प्रदाताओं का स्वत: पता लगाता है और उन्हें अलग करता है
• स्वचालित विफलता: बैकअप प्रदाता पर निर्बाध रूप से स्विच करता है - कोई कोड परिवर्तन की आवश्यकता नहीं है
• प्रदाता स्वास्थ्य निगरानी: प्रति प्रदाता त्रुटि दर और विलंबता को लगातार ट्रैक करता है
• Retry तर्क: क्षणिक त्रुटियाँ (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

गार्डरेल

Harmful content filter करने और compliance policies लागू करने के लिए API requests में content-safety mechanism जोड़ें। BazaarLink अभी सिर्फ organization level पर customizable content-filter guardrails देता है; personal (non-org) API keys के लिए कोई equivalent setting नहीं है — content safety पूरी तरह upstream model provider के अपने built-in safety systems पर निर्भर करती है।

Planned Features (personal और org keys दोनों में अभी तक उपलब्ध नहीं)

वर्तमान व्यवहार

Personal API keys: सभी upstream providers के अपने content safety systems हैं — content filter trigger करने वाले model responses finish_reason: "content_filter" के साथ आते हैं, और BazaarLink कोई additional filtering नहीं करता। Organization API keys: org_admin "Content Filter Guardrails" में custom rules (block/redact/flag) set कर सकते हैं, जो text model तक पहुँचने से पहले लागू होते हैं।

Cursor IDE एकीकरण

BazaarLink को Cursor के OpenAI Override URL के रूप में सेट करें। Responses API ऑटो-कन्वर्जन, टूल फॉर्मेट सामान्यीकरण और Claude मॉडल के लिए bz- प्रीफिक्स सम्मेलन के साथ ड्रॉप-इन सेटअप।

त्वरित सेटअप

Cursor में Settings → Models खोलें, फिर:

1. Override OpenAI Base URL को https://bazaarlink.ai/v1 पर सेट करें
2. Override OpenAI API Key को अपनी sk-bl-... BazaarLink key पर सेट करें
3. अपना मॉडल नाम जोड़ें — Claude के लिए नीचे bz- prefix देखें।

bz- prefix (Claude मॉडल के लिए)

Cursor की client-side validation claude- से शुरू होने वाले किसी भी मॉडल नाम को Cursor की अपनी Anthropic integration से होकर भेजती है, आपके Override URL को बायपास करती है। Cursor को BazaarLink पर भेजने के लिए, मॉडल नाम के सामने bz- जोड़ें। Server prefix हटा देता है और alias map से बाकी resolve करता है।

Dot vs hyphen variants normalize होते हैं: bz-claude-sonnet-4.6 और bz-claude-sonnet-4-6 दोनों एक ही मॉडल पर resolve होते हैं।

CURSOR_MODEL_MAP env var (ऑपरेटर ओवरराइड)

स्व-होस्टेड BazaarLink परिनियोजन के लिए, यह env var सेट करके Cursor-साइड मॉडल नामों को कैटलॉग canonical id पर री-मैप करें:

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

अब Cursor में टाइप किया gpt-claude-sonnet server-side पर anthropic/claude-sonnet-4.6 पर map होता है। यह तब उपयोगी है जब आप चाहते हैं कि Cursor को मॉडल GPT-family लगे (ताकि Override URL से route हो) लेकिन आप वास्तव में Claude serve करें।

जो स्वचालित रूप से होता है

जब request /api/v1/chat/completions पर पहुंचता है, BazaarLink ये compatibility transforms transparently apply करता है — client-side पर कुछ नहीं करना है:

• Responses API bodies auto-detect — अगर body में messages के बजाय input है, इसे Chat Completions shape में convert किया जाता है (Cursor GPT-family models के लिए Responses API format भेजता है)।
• Flat tool definitions wrap करता है — Cursor Agent { name, description, parameters } बिना function wrapper के भेजता है। हम wrap करते हैं ताकि Anthropic Tool '' not found in provided tools के साथ reject न करे।
• Malformed tool_choice को coerce करता है — Cursor { type: "auto" } भेजता है (object form, function नहीं)। OpenAI spec auto/none/required के लिए string form चाहता है, इसलिए हम coerce करते हैं।
• Non-OpenAI providers पर route करते समय OpenAI-only fields हटाता है — parallel_tool_calls, logprobs, top_logprobs, logit_bias, service_tier, user को forward करने से पहले हटा दिया जाता है (अन्यथा Anthropic 400 लौटाता है)।
• max_output_tokens → max_tokens map करता है और Responses-API-only fields (previous_response_id, truncation, background, store) हटाता है। reasoning field Chat-Completions-native bodies के लिए preserve होता है।

Cursor Agent मोड

Tool calling standard Chat Completions tool-call flow से काम करता है। Cursor tools (Shell, Read, Write, Grep, आदि) tool_choice: "auto" के साथ भेजता है; BazaarLink आपके चुने provider को forward करता है, जो tool call करना है या नहीं तय करता है। Tool calls standard OpenAI tool_calls deltas के रूप में return होते हैं; Cursor locally execute करता है और conversation जारी रखता है। gpt-4o (native OpenAI) या bz-claude-sonnet-4.6 चुनें, दोनों एक जैसे काम करते हैं।

मॉडल रूटिंग

BazaarLink अनुरोधों को सही अपस्ट्रीम प्रदाता तक रूट करने के लिए provider/model-name प्रारूप का उपयोग करता है। यह आपको एकल API एंडपॉइंट के माध्यम से सभी प्रमुख मॉडलों तक पहुंच प्रदान करता है।

मॉडल आईडी प्रारूप

{provider}/{model-name}

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

रूटिंग प्राथमिकता

जब आप एक अनुरोध भेजते हैं, तो BazaarLink अपस्ट्रीम प्रदाता को इस क्रम में हल करता है:

1. सटीक मिलान - पूर्ण मॉडल आईडी से मेल खाने वाले मॉडल मार्ग की तलाश करता है
2. Provider वाइल्डकार्ड - प्रदाता/* मार्गों पर वापस आ जाता है (उदा. openai/*)
3. वैश्विक वाइल्डकार्ड - *वाइल्डकार्ड मार्गों पर वापस आ जाता है
4. Default provider key — केवल ज्ञात catalog model के लिए enabled और default चिह्नित key का उपयोग

पर सभी उपलब्ध मॉडल ब्राउज़ करें मॉडल पेज.

ऑटो राउटर

Auto Router v3 अनुरोध को 14 task tiers में से एक में score करता है और उस tier की मौजूदा primary तथा fallback chain उपयोग करता है। Paid और free tables admin console में अलग-अलग प्रबंधित होते हैं।

• auto — paid routing table; सफल वास्तविक model के published price पर billing होती है।
• auto:free — free routing table; free quota के भीतर cost $0 है। quota समाप्त होने पर balance वाले accounts paid fallback बंद न होने पर paid auto पर जा सकते हैं।

कैसे उपयोग करें

स्वचालित रूटिंग सक्षम करने के लिए मॉडल को "ऑटो" (भुगतान) या "ऑटो: फ्री" (फ्री) पर सेट करें:

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 tier कैसे चुनता है

General tiers simple, standard, complex और reasoning हैं। Specialized tiers coding, vision, image, video, data, search, social, email, calendar और trading हैं। Low-confidence boundary result एक स्तर ऊपर किया जाता है।

• Tier scoring: messages, tools, length, keywords और structure से 14 tiers में से एक चुना जाता है
• Hard overrides: vision, formal reasoning और specialized tasks सीधे tier चुन सकते हैं
• Route lookup: मौजूदा primary और अधिकतम पाँच fallbacks पढ़ता है; disabled tier 503 लौटाता है
• Execution: primary के बाद configured fallback chain क्रम से आज़माई जाती है
• Response ट्रैकिंग: हल किया गया मॉडल प्रतिक्रिया निकाय और X-ऑटो-रिज़ॉल्व्ड-मॉडल हेडर में लौटाया जाता है

वर्तमान model tables

नीचे वही live configuration है जो inference और admin उपयोग करते हैं। हर tier की primary, fallback order और enabled state बिना deployment बदली जा सकती है।

auto

auto:free

चुनिंदा मॉडल दर-सीमित मुफ़्त टियर प्रदान करते हैं। मुफ़्त पात्रता प्लेटफ़ॉर्म द्वारा प्रति मॉडल दी जाती है — मॉडल को उसकी सामान्य ID से कॉल करें; :free प्रत्यय एक वैकल्पिक उपनाम है (सशुल्क मॉडल में जोड़ने से वह मुफ़्त नहीं होता)।

मॉडल वेरिएंट

रूटिंग व्यवहार को बदलने के लिए किसी भी मॉडल आईडी में एक प्रत्यय जोड़ें। BazaarLink 7 प्रकार के प्रकारों का समर्थन करता है।

स्वतंत्र मॉडल आईडी

ये वेरिएंट अपनी कीमत और क्षमताओं के साथ अलग-अलग मॉडल के रूप में मौजूद हैं। BazaarLink पहले पूर्ण मॉडल आईडी (प्रत्यय के साथ) आज़माता है, फिर बेस मॉडल पर वापस आता है।

:free
:extended
:thinking
:exacto

रूटिंग शॉर्टकट

ये प्रत्यय मॉडल पहचान को बदले बिना प्रदाता चयन को संशोधित करते हैं। मार्गों के मिलान से पहले प्रत्यय को हटा दिया जाता है।

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

मल्टी-प्रदाता व्यवहार

अपस्ट्रीम के लिए जो वेरिएंट का समर्थन करते हैं, प्रत्यय को वैसे ही पारित किया जाता है। प्रत्यक्ष प्रदाताओं (उदाहरण के लिए, डायरेक्ट OpenAI, फायरवर्क्स) के लिए, प्रत्यय हटा दिया गया है और BazaarLink स्थानीय रूप से रूटिंग को संभालता है।

मुफ़्त मॉडल

चुनिंदा मॉडल दर-सीमित मुफ़्त टियर प्रदान करते हैं। मुफ़्त पात्रता प्लेटफ़ॉर्म द्वारा प्रति मॉडल दी जाती है — मॉडल को उसकी सामान्य ID से कॉल करें; :free प्रत्यय एक वैकल्पिक उपनाम है (सशुल्क मॉडल में जोड़ने से वह मुफ़्त नहीं होता)।

• सामान्य मॉडल ID (जैसे deepseek/deepseek-v4-flash) से कॉल करें। मुफ़्त कोटा के भीतर अनुरोध स्वतः निःशुल्क सेवित होते हैं।
• मुफ़्त उपयोग प्रति उपयोगकर्ता प्रति मिनट अनुरोध और दैनिक सीमा से सीमित है। सीमाएँ खाता स्तर (बिना क्रेडिट / क्रेडिट सहित) के अनुसार बदलती हैं।
• मुफ़्त कोटा पार करने पर यदि आपके पास क्रेडिट है, तो अनुरोध सूचीबद्ध कीमत पर सशुल्क टियर पर स्वतः जारी रहते हैं। स्वचालित फ़ॉलबैक बंद करने और 429 पाने के लिए X-Free-Fallback: false भेजें। क्रेडिट न होने पर कोटा-पार अनुरोध 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. सदस्य का मासिक बजट (OrgMember.monthlyBudget)
2. टीम मासिक बजट (टीम.मासिक बजट)
3. Org क्रेडिट शेष (संगठन.क्रेडिट)

Usage रिपोर्ट

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

• अवलोकन: कुल खर्च, मार्जिन दर, दैनिक रुझान चार्ट
• टीम द्वारा: प्रति-टीम खर्च, शेयर%, मॉडल विश्लेषण, बजट उपयोग
• By मॉडल: प्रति-मॉडल खर्च, औसत मूल्य ($/1M टोकन)
• By सदस्य: प्रति सदस्य खर्च - केवल org_admin

सभी दृश्य प्रत्यक्ष एक्सेल संगतता के लिए BOM उपसर्ग के साथ CSV निर्यात का समर्थन करते हैं।

संगठन बनाएं और प्रबंधित करें

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 Reference

अनुमत मॉडल (Whitelist)

नियंत्रित करें कि आपके संगठन, टीमें या व्यक्तिगत सदस्य कौन-से मॉडल call कर सकते हैं। महंगे या unvetted मॉडल block करने, मॉडल standards लागू करने, या किसी टीम को एक ही provider तक सीमित करने के लिए उपयोगी।

यह कैसे काम करता है

• तीन स्वतंत्र layers — Organization, Team, Member — प्रत्येक की अपनी list होती है (database में String[])।
• जब तीनों layers खाली हों, तो हर मॉडल अनुमत है (default behavior)।
• जब एक या अधिक layers non-empty हों, तो effective list non-empty layers का intersection होती है — मॉडल को pass करने के लिए हर restricted layer पर अनुमत होना चाहिए।
• बदलाव कुछ ही seconds में प्रभावी होते हैं (60s in-memory + 5min Redis cache; update पर दोनों clear हो जाते हैं)।

पैटर्न प्रारूप

• Exact match — जैसे openai/gpt-4o (केवल यह exact मॉडल)।
• Provider wildcard — जैसे openai/* (openai/ prefix के अंतर्गत कोई भी मॉडल)।
• केवल lowercase। प्रति list अधिकतम 200 entries, प्रति entry 100 chars।

कहाँ manage करें

Org Portal → Allowed Models। org_admin org / team / member lists edit कर सकते हैं; team_admin अपनी टीम और उसके सदस्यों को edit कर सकते हैं।

Block होने पर Error response

किसी disallowed मॉडल को call करने पर HTTP 403 इस body के साथ return होता है:

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

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

प्रबंधन API

सभी endpoints Web Session या Bearer Management Key (sk-bl-...) accept करते हैं। PATCH पूरी list को replace करता है; clear करने के लिए [] pass करें।

# 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"]}'

सर्किट ब्रेकर (खर्च किल स्विच)

एक dual-window spend cap जो upstream cost spike होने पर आगे की requests को block कर देता है। runaway scripts, infinite loops, या stolen-key abuse को असली पैसे खर्च करने से पहले रोकने के लिए designed है।

यह कैसे काम करता है

• प्रत्येक scope के लिए Redis में दो fixed windows track होती हैं: 1-minute और 1-hour upstream cost (USD)।
• यदि किसी भी window का spend उसके threshold तक पहुँच जाए, तो उस scope की सभी आगामी requests reject कर दी जाती हैं जब तक window रीसेट नहीं हो जाती।
• Defaults: $5 / minute, $20 / hour, default रूप से enabled।
• Counters Redis में TTL के साथ रहते हैं — recovery automatic है, org/team/member trips के लिए manual reset की ज़रूरत नहीं।

Scopes (member, team को override करता है; team, org को override करता है)

हर layer अपने thresholds set कर सकती है। Resolution order है member → team → org → platform default — प्रत्येक field (cbEnabled, cbMinuteUsd, cbHourlyUsd) के लिए पहला non-null value जीतता है।

• Org level — संगठन के अंतर्गत सभी keys पर लागू। Org Portal → Circuit Breaker में set करें।
• Team level — उस team को tagged सभी keys पर लागू। उन keys के लिए org को override करता है।
• Member level — केवल उस member को tagged keys पर लागू। team और org दोनों को override करता है।

ट्रिप व्यवहार

Trip होने पर requests fail fast हो जाती हैं (कोई upstream call नहीं किया जाता)। 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 और हर configuration change record होता है:

• Trip events — actions org.cb.tripped / team.cb.tripped / org_member.cb.tripped। प्रति scope+window प्रति घंटे एक entry तक deduplicated, ताकि सतत trip log में बाढ़ न ला दे।
• Config changes — actions org.cb.update / team.cb.update / org_member.cb.update। before/after values के साथ-साथ actor capture करते हैं।

प्रबंधन API

Org admins API के माध्यम से settings पढ़ और update कर सकते हैं। सभी endpoints Web Session या Bearer Management Key (sk-bl-...) accept करते हैं। PATCH body में fields का कोई भी subset भेजें; null किसी field को clear करता है और parent layer पर fall back करता है।

# 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 शून्य-डाउनटाइम कुंजी रोटेशन का समर्थन करता है - पहले एक नई कुंजी बनाएं, फिर माइग्रेट करें, फिर पुरानी कुंजी को रद्द करें।

रोटेशन चरण

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 }]
}

Usage लेखांकन

Query 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 (संस्थान योजना)

Institution Plan किसी भी संस्थान (स्कूल, उद्यम, सम्मेलन, सरकारी विभाग आदि) को एक ही org-स्तरीय कुंजी से सदस्यों को अल्पकालिक session token जारी करने देता है। सदस्यों को platform पर account बनाने की आवश्यकता नहीं है। संगठन यह नियंत्रित करता है कि कौन से सदस्य email domain (जैसे nthu.edu.tw) के आधार पर token का अनुरोध कर सकते हैं; सभी उपयोग का बिल संगठन के account पर भेजा जाता है। यह पृष्ठ शिक्षा परिदृश्य को उदाहरण के रूप में उपयोग करता है — वही तंत्र किसी भी संस्थान के लिए काम करता है जिसे अल्पकालिक, बहु-उपयोगकर्ता अस्थायी पहुंच की आवश्यकता होती है।

Architecture अवलोकन

• संस्थान कुंजी — sk-edu- से शुरू होती है। org keys page पर org_admin द्वारा बनाई जाती है। API को call करने के लिए सीधे Bearer token के रूप में उपयोग नहीं की जा सकती — सीधे calls 403 लौटाते हैं।
• सदस्य सत्र टोकन — edu-sess- से शुरू होता है। छात्र इसे email सत्यापन के बाद प्राप्त करते हैं। डिफ़ॉल्ट जीवनकाल 24 घंटे है; org admin द्वारा रद्द किया जा सकता है।
• अनुमत डोमेन — संगठन यह कॉन्फ़िगर करता है कि कौन से email domains (सटीक मिलान, कोई suffix bypass नहीं) session का अनुरोध कर सकते हैं।
• Usage एट्रिब्यूशन — सभी छात्र अनुरोधों का बिल org account पर भेजा जाता है। उपयोग org dashboard में प्रति session और प्रति email देखा जा सकता है।

चरण 1 — Platform admin org type को Education पर सेट करता है

sales@bazaarlink.ai / support@bazaarlink.ai से, लक्षित org खोजें, "Org Type" tab पर जाएँ, Education चुनें, और अनुमत email domains सेट करें:

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

चरण 2 — Org admin एक Institution Key बनाता है

org के API Keys page पर, नई key बनाते समय key type के रूप में "Education" चुनें। System एक sk-edu-... key उत्पन्न करता है और इसे केवल एक बार दिखाता है — इसे सहेजें और अपने आधिकारिक channels के माध्यम से उस org के छात्रों को वितरित करें।

चरण 3 — छात्र सत्यापन code का अनुरोध करता है

छात्र /access पर जाते हैं और edu key + अपना स्कूल email दर्ज करते हैं; या API को सीधे call करते हैं:

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 के बदले code submit करता है

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 — API को call करने के लिए session token का उपयोग करें

किसी भी chat / completions / embeddings endpoint के विरुद्ध edu-sess-... token को Bearer token के रूप में उपयोग करें:

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"}]
  }'

Org dashboard — निगरानी और रद्दीकरण

Education-type orgs को side nav में एक Education tab मिलता है, जो प्रदान करता है:

• सेटिंग्स — अनुमत domains, TTL, प्रति email प्रति key अधिकतम sessions, और प्रति-session request / token / USD quotas समायोजित करें।
• सत्र — सभी सक्रिय / समाप्त / रद्द किए गए sessions की सूची; email द्वारा filter करें; अलग-अलग sessions रद्द करें।
• Uउपयोग आँकड़े — प्रति-session call संख्या, token खपत, और संचित लागत।

सुरक्षा और सीमाएँ

बिलिंग और उपयोग attribution

session tokens के माध्यम से किए गए सभी अनुरोधों का बिल 100% उस संगठन को भेजा जाता है जो edu key का स्वामी है, उसी तरह जैसे upstream providers (OpenAI / Anthropic / आदि) बिल भेजते हैं (per-token)। Org dashboard session, email, और key द्वारा drill-down का समर्थन करता है।

रिपोर्ट फीडबैक

समस्याओं, बगों या सुझावों की रिपोर्ट करके BazaarLink को बेहतर बनाने में हमारी सहायता करें। हम सभी फीडबैक चैनलों की सक्रिय रूप से निगरानी करते हैं।

रिपोर्ट कैसे करें

क्या शामिल करें

• Request ID (प्रतिक्रिया आईडी फ़ील्ड से)
• मॉडल का उपयोग किया गया और पैरामीटर भेजे गए
• अपेक्षित बनाम वास्तविक व्यवहार
• टाइमस्टैम्प और जारी करने की आवृत्ति
• त्रुटि संदेश या HTTP स्थिति कोड

प्रतिक्रिया सबमिट करने के लिए हमारे संपर्क पृष्ठ पर जाएँ।

FAQ