---
title: "OpenAI API से माइग्रेट करें: कोड के बदलाव और टेस्ट | BroadRouter"
description: "OpenAI से OpenAI-कम्पैटिबल API पर जाने के लिए कोड के बदलाव: क्लाइंट सेटअप, Responses से Chat Completions, टूल, स्ट्रीमिंग, embeddings और एक स्मोक टेस्ट।"
url: https://broadrouter.com/hi/blog/migrate-from-openai-api-code-walkthrough/
lang: hi
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/migrate-from-openai-api-code-walkthrough/) (2026-11-15 को अपडेट किया गया).

# OpenAI API से माइग्रेशन: Python, Node और cURL में कोड वॉकथ्रू

BroadNet Inference टीम · 6 मिनट में पढ़ें · प्रकाशित 2026-11-15

क्लाइंट का base URL, API key और मॉडल ID बदलें। Chat Completions कॉल के लिए इतना काफ़ी है। Responses API वाला कोड Chat Completions में दोबारा लिखना होगा: input, messages बन जाता है, output\_text, choices\[0\].message.content बन जाता है, और टूल का एक नेस्टिंग स्तर बदलता है। नए प्रोवाइडर के पास embeddings न हों, तो उन्हें अलग क्लाइंट पर रखें, फिर ट्रैफ़िक बदलने से पहले स्मोक टेस्ट चलाएँ।

## मुख्य बातें

-   Chat Completions वाले कोड के लिए बदलाव तीन मानों का है: base\_url, api\_key और model। दोनों आधिकारिक SDK एनवायरनमेंट से OPENAI\_BASE\_URL और OPENAI\_API\_KEY भी पढ़ते हैं।
-   OPENAI\_BASE\_URL सेट करने से हर कॉल बदल जाती है, embeddings समेत। अगर नए प्रोवाइडर के पास embeddings एंडपॉइंट नहीं है, तो embeddings को अपना अलग क्लाइंट दें।
-   Responses API वाले कोड को दोबारा लिखना होगा: input से messages, instructions से सिस्टम संदेश, text.format से response\_format, और फ़्लैट टूल डेफ़िनिशन से नेस्टेड डेफ़िनिशन।
-   BroadNet Inference, /v1/chat/completions, /v1/audio/transcriptions और GET /v1/models डॉक्यूमेंट करता है, और कोई embeddings, files या batch एंडपॉइंट नहीं। उसका डॉक्यूमेंटेशन GLM 5.3 और Qwen3.8 27B के लिए टूल और स्ट्रक्चर्ड आउटपुट दिखाता है।
-   बदलने से पहले टेस्ट करें: सामान्य चैट, स्ट्रीमिंग usage, रीज़निंग बजट और एक ग़लत key, और अगर आप टूल इस्तेमाल करते हैं तो एक टूल कॉल भी।

**इस पेज पर**

1.  क्लाइंट सेटअप में क्या बदलता है?
2.  अगर मेरा कोड Responses API इस्तेमाल करता है तो?
3.  टूल कॉल कैसे बदलती हैं?
4.  स्ट्रक्चर्ड आउटपुट का क्या?
5.  embeddings का क्या होता है?
6.  स्ट्रीमिंग कोड कैसे बदलता है?
7.  क्या एरर हैंडलिंग और रीट्राई बदलते हैं?
8.  कौन-से पैरामीटर अलग व्यवहार करते हैं?
9.  बदलाव को कैसे टेस्ट करें?
10.  सबसे ज़्यादा क्या टूटता है?
11.  BroadNet Inference कहाँ फ़िट होता है

अगर आप Chat Completions इस्तेमाल करते हैं, तो किसी ऐप को OpenAI से OpenAI-कम्पैटिबल प्रोवाइडर पर ले जाना कोड का छोटा-सा बदलाव है, और अगर Responses API इस्तेमाल करते हैं, तो दोबारा लिखना पड़ता है। यह पोस्ट Python, Node और cURL में सटीक diff दिखाती है, बताती है कि Responses, टूल, स्ट्रक्चर्ड आउटपुट और embeddings के साथ क्या करें, और एक स्मोक टेस्ट देती है जो कोई भी ट्रैफ़िक बदलने से पहले चलाना चाहिए। उदाहरणों में `https://inference.broadnet.ai/v1` पर BroadNet Inference इस्तेमाल हुआ है; यही कदम किसी भी प्रोवाइडर पर लागू होते हैं।

यह [माइग्रेशन चेकलिस्ट](https://broadrouter.com/hi/blog/openai-compatible-api-migration-checklist/) का कोड वाला साथी है, जो रेट लिमिट, एरर और कटओवर की योजना समझाती है। दूसरे प्रोवाइडर के base URL के लिए [OpenAI-कम्पैटिबल base URL, जाँचे हुए](https://broadrouter.com/hi/blog/openai-compatible-api-base-urls/) देखें।

## क्लाइंट सेटअप में क्या बदलता है?

तीन मान: base URL, API key और मॉडल ID।

**Python**

```python
import os
from openai import OpenAI

# before: client = OpenAI()  # reads OPENAI_API_KEY, calls api.openai.com
client = OpenAI(
    base_url="https://inference.broadnet.ai/v1",
    api_key=os.environ["BROADNET_API_KEY"],
)
r = client.chat.completions.create(
    model="broadnet/gemma-4-26b-a4b",          # was e.g. "gpt-..."
    messages=[{"role": "user", "content": "Reply with one short sentence."}],
)
print(r.choices[0].message.content)
```

**Node**

```javascript
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://inference.broadnet.ai/v1",
  apiKey: process.env.BROADNET_API_KEY,
});
const r = await client.chat.completions.create({
  model: "broadnet/gemma-4-26b-a4b",
  messages: [{ role: "user", content: "Reply with one short sentence." }],
});
console.log(r.choices[0].message.content);
```

**cURL**

```bash
curl https://inference.broadnet.ai/v1/chat/completions \
  -H "Authorization: Bearer $BROADNET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"broadnet/gemma-4-26b-a4b","messages":[{"role":"user","content":"Reply with one short sentence."}]}'
```

पाथ पर ध्यान दें: base URL पहले से `/v1` पर ख़त्म होता है, इसलिए SDK उसमें `/chat/completions` जोड़ता है। `/v1` दो बार लिख देना सबसे आम पहली ग़लती है।

### क्या कोड छुए बिना बदलाव हो सकता है?

हाँ, Chat Completions वाले कोड के लिए। जब कोई `base_url` पास नहीं किया जाता, तो Python SDK `OPENAI_BASE_URL` पढ़ता है, और Node क्लाइंट का `baseURL` डिफ़ॉल्ट रूप से `process.env['OPENAI_BASE_URL']` होता है। दोनों `OPENAI_API_KEY` पढ़ते हैं। दो एनवायरनमेंट वेरिएबल सेट करने से हर कॉल बदल जाती है।

जोखिम भी यही है। **हर कॉल** बदलती है, embeddings, moderation, फ़ाइल अपलोड और ऐसी हर चीज़ समेत जो शायद नए प्रोवाइडर के पास न हो। एनवायरनमेंट वाला तरीक़ा सिर्फ़ तब इस्तेमाल करें जब आपका ऐप चैट कॉल के अलावा कुछ नहीं करता।

## अगर मेरा कोड Responses API इस्तेमाल करता है तो?

OpenAI के SDK README अब Responses API को मुख्य API कहते हैं; Python README, Chat Completions को “the previous standard (supported indefinitely)” (अनुवाद: पिछला मानक (अनिश्चित काल तक सपोर्टेड)) कहता है। कई कम्पैटिबल प्रोवाइडर सिर्फ़ Chat Completions लागू करते हैं। BroadNet, `POST /v1/chat/completions` और `POST /v1/audio/transcriptions` डॉक्यूमेंट करता है, इसलिए Responses कॉल दोबारा लिखनी होंगी। मैपिंग:

| Responses API | Chat Completions |
| --- | --- |
| `client.responses.create(...)` | `client.chat.completions.create(...)` |
| `instructions="..."` | पहला संदेश `{"role": "system", "content": "..."}` |
| `input="..."` या आइटम की सूची | `messages=[...]` |
| `response.output_text` | `response.choices[0].message.content` |
| `max_output_tokens` | `max_tokens` (BroadNet का डॉक्यूमेंटेशन) या `max_completion_tokens` |
| `text={"format": {...}}` | `response_format={...}` |
| `previous_response_id`, conversations | पूरा संदेश इतिहास ख़ुद दोबारा भेजें |
| टूल `{"type": "function", "name": ...}` | टूल `{"type": "function", "function": {"name": ...}}` |
| आउटपुट आइटम `function_call`, जवाब `function_call_output` और `call_id` के साथ | `message.tool_calls`, जवाब role `tool` और `tool_call_id` के साथ |
| बिल्ट-इन टूल (वेब सर्च, फ़ाइल सर्च) | उपलब्ध नहीं; अपना टूल चलाएँ |

एक सरल कॉल का पहले और बाद का रूप:

```python
# Before: Responses API
r = client.responses.create(model="gpt-...", instructions="Be brief.", input="What is RAG?")
text = r.output_text

# After: Chat Completions
r = client.chat.completions.create(
    model="broadnet/gemma-4-26b-a4b",
    messages=[{"role": "system", "content": "Be brief."},
              {"role": "user", "content": "What is RAG?"}],
)
text = r.choices[0].message.content
```

सबसे बड़ा ढाँचागत बदलाव स्टेट का है। Responses, `previous_response_id` से बातचीत का स्टेट OpenAI की तरफ़ रख सकता है। Chat Completions में सर्वर पर कोई स्टेट नहीं होता, इसलिए आपका कोड संदेशों की सूची सहेजता है और हर टर्न पर पूरी सूची भेजता है। इसका बजट रखें: पूरा इतिहास हर कॉल पर इनपुट टोकन है।

## टूल कॉल कैसे बदलती हैं?

Chat Completions में टूल डेफ़िनिशन, फ़ंक्शन को `function` key के अंदर नेस्ट करती है, और जवाब `tool` संदेश के रूप में वापस जाता है:

```python
import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_order",
        "description": "Look up an order by ID.",
        "parameters": {"type": "object",
                       "properties": {"order_id": {"type": "string"}},
                       "required": ["order_id"]},
    },
}]
messages = [{"role": "user", "content": "Where is order A-1042?"}]
r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)
msg = r.choices[0].message
if msg.tool_calls:
    messages.append(msg)                                   # keep the assistant turn
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)         # a JSON string: parse and validate it
        messages.append({"role": "tool", "tool_call_id": call.id,
                         "content": json.dumps(lookup_order(args["order_id"]))})
    r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)
```

ढाँचे से ज़्यादा मॉडल मायने रखता है। BroadNet का डॉक्यूमेंटेशन टूल सिर्फ़ [GLM 5.3](https://broadrouter.com/hi/models/glm-5.3/) और [Qwen3.8 27B](https://broadrouter.com/hi/models/qwen3.8-27b/) के लिए दिखाता है। टूल लूप को ऐसे मॉडल पर न लगाएँ जिसके डॉक्यूमेंटेशन में टूल नहीं हैं, और कुछ भी चलाने से पहले आर्ग्युमेंट वैलिडेट करें। [ओपन मॉडल के साथ टूल कॉलिंग](https://broadrouter.com/hi/blog/tool-calling-open-models/) में वैलिडेशन वाला पूरा लूप है।

## स्ट्रक्चर्ड आउटपुट का क्या?

`client.chat.completions.parse(..., response_format=MyPydanticModel)` और Node का `zodResponseFormat`, दोनों JSON schema के साथ `response_format` भेजते हैं। ये तभी काम करते हैं जब प्रोवाइडर उस मॉडल पर यह ढाँचा स्वीकार करता हो। BroadNet, GLM 5.3 और Qwen3.8 27B के लिए स्ट्रक्चर्ड आउटपुट दिखाता है, लेकिन अनुरोध का पैरामीटर नहीं बताता। [JSON mode बनाम json\_schema](https://broadrouter.com/hi/blog/structured-output-json-schema/) वाला चार कदमों का टेस्ट हर मॉडल पर एक बार चलाएँ, और प्रोवाइडर चाहे जो वादा करे, पार्स किए गए नतीजे को वैलिडेट करते रहें।

## embeddings का क्या होता है?

अगर आप किसी साझा क्लाइंट पर base URL बदलते हैं और प्रोवाइडर के पास embeddings एंडपॉइंट नहीं है, तो हर `client.embeddings.create` कॉल फ़ेल होगी। BroadNet [embeddings](https://broadrouter.com/hi/glossary/embeddings/) नहीं बेचता। दो क्लाइंट रखें:

```python
chat = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
embed = OpenAI(api_key=os.environ["OPENAI_API_KEY"])   # or any embeddings provider

vec = embed.embeddings.create(model="text-embedding-3-small", input=query).data[0].embedding
answer = chat.chat.completions.create(model="broadnet/glm-5.3", messages=build_prompt(query, search(vec)))
```

एक इंडेक्स में दो embedding मॉडल के वेक्टर कभी न मिलाएँ। अगर आप embedding प्रोवाइडर भी बदलते हैं, तो पूरे कॉर्पस को दोबारा embed करें। [embedding कॉस्ट कैलकुलेटर](https://broadrouter.com/tools/embedding-cost-calculator/) उसकी कीमत निकालता है।

यही बात हर उस चीज़ पर लागू होती है जो चैट नहीं है: इमेज जेनरेशन, टेक्स्ट-टू-स्पीच, moderation, Batch API और फ़ाइल स्टोरेज। BroadNet इनमें से कुछ नहीं देता। स्पीच-टू-टेक्स्ट ज़रूर बदला जा सकता है: `client.audio.transcriptions.create`, WAV या MP3 और एक `language` फ़ील्ड के साथ `/v1/audio/transcriptions` पर काम करता है ([अरबी स्पीच-टू-टेक्स्ट गाइड](https://broadrouter.com/hi/guides/arabic-speech-to-text-api/))।

## स्ट्रीमिंग कोड कैसे बदलता है?

Responses API टाइप किए गए इवेंट स्ट्रीम करता है, जैसे `response.output_text.delta` और `response.completed`। Chat Completions चंक स्ट्रीम करता है, और टेक्स्ट `choices[0].delta.content` में होता है। usage तब तक नहीं भेजा जाता जब तक आप उसे न माँगें, और फिर वह ख़ाली `choices` सूची वाले आख़िरी चंक में आता है।

```javascript
// Before (Responses): for await (const e of stream) if (e.type === "response.output_text.delta") out(e.delta);
const stream = await client.chat.completions.create({
  model: "broadnet/gemma-4-26b-a4b",
  messages: [{ role: "user", content: "Count from one to three." }],
  stream: true,
  stream_options: { include_usage: true },
});
for await (const chunk of stream) {
  const text = chunk.choices[0]?.delta?.content;
  if (text) process.stdout.write(text);
  if (chunk.usage) console.log("\ntokens:", chunk.usage.total_tokens);   // last chunk
}
```

बदलाव के बाद दो आदतें स्ट्रीम कोड को सुरक्षित रखती हैं। `choices[0]` की जाँच करें, क्योंकि usage वाले चंक में कोई choice नहीं होता। और जो स्ट्रीम आख़िरी `data: [DONE]` लाइन से पहले ख़त्म हो जाए, उसे अधूरा मानें; BroadNet का डॉक्यूमेंटेशन कहता है कि `X-Request-ID` दर्ज करें और तय करें कि नया अनुरोध सुरक्षित है या नहीं। [स्ट्रीमिंग chat completions](https://broadrouter.com/hi/guides/streaming-chat-completions/) में Python में पूरा पैटर्न है।

## क्या एरर हैंडलिंग और रीट्राई बदलते हैं?

SDK की एरर क्लास वही रहती हैं: 401 के लिए `AuthenticationError`, 429 के लिए `RateLimitError`, बाक़ी के लिए `APIStatusError`। बदलता यह है कि नए प्रोवाइडर पर हर स्टेटस का मतलब क्या है। BroadNet पर 401 का मतलब सिर्फ़ ग़लत key नहीं, उपयोग के अनुसार भुगतान का ख़त्म हुआ अलाउंस भी हो सकता है, और 402 का मतलब है किसी ख़रीद के लिए अपर्याप्त बैलेंस। दोनों में से कोई रीट्राई से ठीक नहीं होता। 429 रेट, कॉन्करेंसी, टोकन-रेट या ख़र्च की सीमा से आ सकता है। 429 और 5xx को बैकऑफ़ के साथ रीट्राई करें, और बाक़ी सब ठीक करें। [एरर और रीट्राई गाइड](https://broadrouter.com/hi/guides/errors-and-retries/) में पूरी टेबल है।

SDK कनेक्शन एरर, 408, 409, 429 और 5xx को डिफ़ॉल्ट रूप से दो बार रीट्राई करता है। अगर आप अपना रीट्राई लूप जोड़ते हैं, तो क्लाइंट पर `max_retries=0` सेट करें ताकि दोनों एक के ऊपर एक न चढ़ें।

## कौन-से पैरामीटर अलग व्यवहार करते हैं?

| पैरामीटर | क्या जाँचें |
| --- | --- |
| `max_tokens` / `max_completion_tokens` | OpenAI, `max_tokens` को डेप्रिकेट करता है; BroadNet का डॉक्यूमेंटेशन इसे इस्तेमाल करता है। रीज़निंग मॉडल पर इसमें थिंकिंग शामिल होती है, इसलिए छोटे मान ख़ाली जवाब लौटाते हैं ([क्यों](https://broadrouter.com/hi/guides/reasoning-tokens-empty-response/)) |
| `reasoning_effort` | BroadNet `low` डॉक्यूमेंट करता है; दूसरे मानों पर भरोसा करने से पहले उन्हें टेस्ट करें |
| `stream_options: {"include_usage": true}` | BroadNet ने डॉक्यूमेंट किया है; usage आख़िरी चंक में आता है |
| `n`, `logprobs`, `seed`, `logit_bias` | BroadNet के डॉक्यूमेंटेशन में नहीं; टेस्ट करें, या हटा दें |
| `store`, `metadata` | OpenAI के स्टोरेज फ़ीचर; इन्हें हटा दें |
| `image_url` कंटेंट पार्ट | सिर्फ़ इमेज वाले मॉडल पर: DeepSeek V4.1 Flash, Qwen3.8 27B, Gemma 4 VL 26B |

## बदलाव को कैसे टेस्ट करें?

कोई भी ट्रैफ़िक बदलने से पहले नए प्रोवाइडर पर एक छोटा स्मोक टेस्ट चलाएँ। यह सामान्य चैट, स्ट्रीमिंग usage, रीज़निंग बजट और ऑथेंटिकेशन जाँचता है। अगर आप टूल इस्तेमाल करते हैं, तो एक टूल-कॉल केस जोड़ें।

```python
import os, openai
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=0)
FAST, REASONING = "broadnet/gemma-4-26b-a4b", "broadnet/qwen3.8-27b"
msg = [{"role": "user", "content": "Reply with the word ok."}]

# 1. Plain chat returns text and usage
r = client.chat.completions.create(model=FAST, messages=msg)
assert r.choices[0].message.content and r.usage.prompt_tokens > 0

# 2. Streaming reports usage in the last chunk
chunks = list(client.chat.completions.create(model=FAST, messages=msg, stream=True,
                                             stream_options={"include_usage": True}))
assert chunks[-1].usage is not None

# 3. A reasoning model needs room: a tiny budget can come back empty
r = client.chat.completions.create(model=REASONING, messages=msg, max_tokens=2000)
assert r.choices[0].finish_reason == "stop" and r.choices[0].message.content

# 4. A bad key raises AuthenticationError (401), which you should not retry
bad = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key="invalid", max_retries=0)
try:
    bad.chat.completions.create(model=FAST, messages=msg)
    raise AssertionError("expected 401")
except openai.AuthenticationError:
    pass
print("smoke test passed")
```

फिर सिर्फ़ ढाँचे की नहीं, क्वालिटी की तुलना करें। असली प्रॉम्प्ट का एक सैंपल दोनों प्रोवाइडर पर दोबारा चलाएँ और जवाबों को स्कोर करें; [बदलने से पहले LLM का मूल्यांकन](https://broadrouter.com/hi/blog/evaluate-llm-before-switching/) इसका तरीक़ा बताता है। [OpenAI से BroadNet माइग्रेशन टूल](https://broadrouter.com/tools/openai-to-broadnet-migration/) किसी स्निपेट को दोबारा लिखने में मदद करता है और बताता है कि वह कौन-से फ़ीचर इस्तेमाल करता है।

## सबसे ज़्यादा क्या टूटता है?

-   **ग्लोबल base URL**, जो embeddings और फ़ाइल कॉल को भी बदल देता है।
-   **सिर्फ़ Responses वाले हेल्पर**, जैसे `output_text`, जो उस कोड में छूट गए जो अब Chat Completions कॉल करता है।
-   **मॉडल ID।** `gpt-...` नाम दूसरी जगह मौजूद नहीं हैं। BroadNet पर वे `broadnet/glm-5.3` जैसे दिखते हैं।
-   **ख़ाली जवाब**, छोटे `max_tokens` वाले रीज़निंग मॉडल से।
-   **रेट लिमिट।** BroadNet की उपयोग के अनुसार भुगतान वाली key प्रति मिनट 30 अनुरोध और एक साथ 4 चालू अनुरोध की अनुमति देती है। बड़े जॉब को क्यू चाहिए ([429 को सँभालना](https://broadrouter.com/hi/blog/handle-llm-api-429-rate-limits/))।

## BroadNet Inference कहाँ फ़िट होता है

BroadNet Inference उन ऐप के लिए ठीक है जिनका OpenAI उपयोग चैट और ट्रांसक्रिप्शन है: असिस्टेंट, एक्सट्रैक्शन, सारांश, अनुवाद और अरबी स्पीच। यह उन ऐप के लिए भी ठीक है जो एजेंट के लिए फ़्लैट रेट वाले [DeepSeek V4.1 Flash](https://broadrouter.com/hi/models/deepseek-v4.1-flash/) प्लान चाहते हैं। अगर आप Responses API के सर्वर-साइड स्टेट, बिल्ट-इन टूल, embeddings, इमेज जेनरेशन, टेक्स्ट-टू-स्पीच, रियलटाइम वॉइस या Batch API पर निर्भर हैं, तो यह सही जगह नहीं है। इन्हें उन प्रोवाइडर पर ले जाएँ जो ये देते हैं, या इन्हें OpenAI पर रहने दें और सिर्फ़ चैट कॉल बदलें। Gemma 4 VL 26B और दोनों ट्रांसक्रिप्शन मॉडल $5 के शुरुआती क्रेडिट पर चलते हैं; GLM 5.3, Qwen3.8 27B और DeepSeek V4.1 Flash के लिए पहले टॉप-अप ज़रूरी है।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[एम्बेडिंग (embeddings)](https://broadrouter.com/hi/glossary/embeddings/)

एम्बेडिंग, फ़्लोटिंग-पॉइंट संख्याओं की सूचियाँ (वेक्टर) हैं जो कोई मॉडल टेक्स्ट, इमेज या दूसरे इनपुट को दर्शाने के लिए बनाता है। मिलते-जुलते अर्थ वाले इनपुट के वेक्टर पास-पास होते हैं, इसलिए वेक्टर के बीच की दूरी से सर्च नतीजों की रैंकिंग, दस्तावेज़ों का समूह बनाना या जुड़ी चीज़ें ढूँढना संभव होता है।

[base URL](https://broadrouter.com/hi/glossary/base-url/)

base URL किसी API का तय मूल पता है, जैसे https://api.example.com/v1, जिसे क्लाइंट /chat/completions जैसे हर एंडपॉइंट पाथ के आगे जोड़ता है। OpenAI-compatible SDK में base URL को API key और मॉडल ID के साथ बदलने से वही कोड किसी दूसरे प्रोवाइडर से जुड़ जाता है।

[Chat Completions API](https://broadrouter.com/hi/glossary/chat-completions-api/)

Chat Completions API, OpenAI का HTTP एंडपॉइंट POST /v1/chat/completions है, जो एक मॉडल का नाम और रोल वाले मैसेज की सूची लेता है और मॉडल का अगला मैसेज लौटाता है। इसके अनुरोध और जवाब का ढाँचा वह आम फ़ॉर्मैट बन गया जिसे OpenAI-कम्पैटिबल प्रोवाइडर और SDK अपनाते हैं।

[उपयोग के अनुसार भुगतान (pay-as-you-go)](https://broadrouter.com/hi/glossary/pay-as-you-go/)

उपयोग के अनुसार भुगतान (pay-as-you-go) एक प्राइसिंग मॉडल है जिसमें आप सिर्फ़ उतना देते हैं जितना इस्तेमाल करते हैं, जिसे टोकन, अनुरोध या ऑडियो मिनट जैसी इकाइयों में मापा जाता है, बिना सब्सक्रिप्शन या न्यूनतम प्रतिबद्धता के। ज़्यादातर LLM API इसी तरह बिल बनाते हैं, प्रीपेड बैलेंस या समय-समय पर बनने वाले इनवॉइस से।

[कॉन्करेंसी (concurrency)](https://broadrouter.com/hi/glossary/concurrency/)

कॉन्करेंसी, किसी क्लाइंट के एक ही समय पर चल रहे (in-flight) अनुरोधों की संख्या है। LLM API अक्सर इसकी सीमा हर key या प्लान पर, प्रति मिनट अनुरोधों से अलग रखते हैं, क्योंकि हर खुला अनुरोध जवाब पूरा होने तक GPU क्षमता घेरे रहता है।

[टूल कॉलिंग (tool calling)](https://broadrouter.com/hi/glossary/tool-calling/)

टूल कॉलिंग, जिसे function calling भी कहते हैं, LLM API की वह सुविधा है जिसमें मॉडल डेवलपर के तय किए किसी फ़ंक्शन को चलाने का एक स्ट्रक्चर्ड अनुरोध, JSON आर्ग्युमेंट के साथ, लौटाता है। ऐप्लिकेशन फ़ंक्शन चलाकर नतीजा वापस भेजता है; मॉडल ख़ुद कभी कोड नहीं चलाता।

[रेट लिमिट (rate limit)](https://broadrouter.com/hi/glossary/rate-limit/)

रेट लिमिट वह सीमा है जो कोई API तय करता है कि एक क्लाइंट किसी समय-अवधि में उसका कितना इस्तेमाल कर सकता है, जैसे प्रति मिनट अनुरोध या प्रति मिनट टोकन। सीमा से ऊपर के अनुरोध ठुकरा दिए जाते हैं, आम तौर पर HTTP 429 Too Many Requests के साथ, जब तक इस्तेमाल फिर सीमा के नीचे न आ जाए।

[स्ट्रक्चर्ड आउटपुट (structured output)](https://broadrouter.com/hi/glossary/structured-output/)

स्ट्रक्चर्ड आउटपुट LLM API का एक फ़ीचर है जो मॉडल के जवाब को डेवलपर के तय फ़ॉर्मैट, आम तौर पर JSON Schema, तक सीमित करता है, ताकि कोड उसे भरोसे से पार्स कर सके। यह JSON mode से सख़्त है, जो मान्य JSON की गारंटी देता है, लेकिन किसी ख़ास ढाँचे की नहीं।

## अक्सर पूछे जाने वाले सवाल

### क्या OpenAI-कम्पैटिबल API के लिए अलग SDK चाहिए?

नहीं। आधिकारिक openai पैकेज ही रखें और अलग base\_url (Python) या baseURL (Node) पास करें, साथ में नए प्रोवाइडर की key। प्रोवाइडर जिन एंडपॉइंट को सपोर्ट करता है, उनके लिए अनुरोध और रिस्पॉन्स ऑब्जेक्ट वही रहते हैं।

### क्या OpenAI-कम्पैटिबल API, Responses API सपोर्ट करता है?

कुछ करते हैं; कई सिर्फ़ Chat Completions सपोर्ट करते हैं। प्रोवाइडर की एंडपॉइंट सूची देखें। BroadNet Inference, /v1/chat/completions और /v1/audio/transcriptions डॉक्यूमेंट करता है, इसलिए Responses वाला कोड Chat Completions में दोबारा लिखना होगा।

### बदलने पर मेरे embeddings का क्या होगा?

अगर नए प्रोवाइडर के पास embeddings एंडपॉइंट नहीं है और आपने base URL हर जगह बदल दिया, तो वे टूट जाएँगे। BroadNet, embeddings नहीं बेचता, इसलिए embeddings क्लाइंट को अपने embeddings प्रोवाइडर की ओर ही रखें। एक इंडेक्स में दो embedding मॉडल के वेक्टर कभी न मिलाएँ।

### max\_tokens भेजूँ या max\_completion\_tokens?

OpenAI, max\_tokens को डेप्रिकेटेड बताता है और उसकी जगह max\_completion\_tokens की सलाह देता है। कई कम्पैटिबल प्रोवाइडर इसकी जगह max\_tokens डॉक्यूमेंट करते हैं, और BroadNet का डॉक्यूमेंटेशन max\_tokens इस्तेमाल करता है। प्रोवाइडर जो डॉक्यूमेंट करता है वही भेजें, और अपने स्मोक टेस्ट में पक्का करें कि सीमा लागू हो रही है।

### क्या OpenAI के स्ट्रक्चर्ड आउटपुट हेल्पर फिर भी काम करेंगे?

सिर्फ़ तब, जब प्रोवाइडर आपके मॉडल पर json\_schema के साथ response\_format स्वीकार करता हो। BroadNet, GLM 5.3 और Qwen3.8 27B के लिए स्ट्रक्चर्ड आउटपुट दिखाता है, लेकिन अनुरोध का पैरामीटर नहीं बताता, इसलिए इसे टेस्ट करें, और पार्स किए गए नतीजे को वैलिडेट करते रहें।

## आगे पढ़ें

-   [OpenAI-कम्पैटिबल API पर माइग्रेट करना: पूरी चेकलिस्ट](https://broadrouter.com/hi/blog/openai-compatible-api-migration-checklist/)
-   [OpenAI-compatible API के base URL: 14 प्रोवाइडर, डॉक्स से जाँचे हुए](https://broadrouter.com/hi/blog/openai-compatible-api-base-urls/)
-   [ओपन मॉडल के साथ टूल कॉलिंग: स्कीमा, पैरेलल कॉल, रीट्राई](https://broadrouter.com/hi/blog/tool-calling-open-models/)
-   [JSON mode बनाम json\_schema: भरोसेमंद स्ट्रक्चर्ड आउटपुट](https://broadrouter.com/hi/blog/structured-output-json-schema/)
-   [प्रोवाइडर बदलने से पहले LLM का मूल्यांकन कैसे करें](https://broadrouter.com/hi/blog/evaluate-llm-before-switching/)
-   [BroadNet का GPU हार्डवेयर और सर्विंग का तरीक़ा, BroadNet के शब्दों में](https://broadrouter.com/hi/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM API रिस्पॉन्स कैश करके लागत घटाएँ: Python में एक्ज़ैक्ट-मैच कैश](https://broadrouter.com/hi/blog/cache-llm-responses-cut-cost/)
-   [गाइड: BroadNet Inference के साथ OpenAI Python SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-python-sdk/)
-   [गाइड: BroadNet Inference के साथ OpenAI Node.js SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-node-sdk/)
-   [गाइड: curl से BroadNet Inference को पहला अनुरोध](https://broadrouter.com/hi/guides/curl-quickstart/)
-   [गाइड: रीज़निंग मॉडल ख़ाली जवाब क्यों लौटाता है](https://broadrouter.com/hi/guides/reasoning-tokens-empty-response/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-migrate-from-openai-api-code-walkthrough&utm_content=page-cta) ·

**स्रोत**

-   [BroadNet Inference API रेफ़रंस: एंडपॉइंट, मॉडल ID, क्षमताएँ, स्ट्रीमिंग usage, एरर (2026-11-15 को देखा गया) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-migrate-from-openai-api-code-walkthrough&utm_content=sources)
-   [openai-python README: Responses मुख्य API है, Chat Completions अनिश्चित काल तक सपोर्टेड, रीट्राई (2026-11-15 को देखा गया)](https://github.com/openai/openai-python)
-   [openai-node क्लाइंट सोर्स: baseURL का डिफ़ॉल्ट OPENAI\_BASE\_URL है (2026-11-15 को देखा गया)](https://github.com/openai/openai-node/blob/master/src/client.ts)
-   [OpenAI, Responses API पर माइग्रेट करें: स्ट्रक्चर्ड आउटपुट, टूल और स्टोरेज में अंतर (2026-11-15 को देखा गया)](https://developers.openai.com/api/docs/guides/migrate-to-responses)
-   [OpenAI function calling गाइड: दोनों API में टूल के ढाँचे (2026-11-15 को देखा गया)](https://developers.openai.com/api/docs/guides/function-calling)
-   [OpenAI Chat Completions रेफ़रंस: max\_tokens डेप्रिकेटेड, उसकी जगह max\_completion\_tokens (2026-11-15 को देखा गया)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
