> ## Documentation Index
> Fetch the complete documentation index at: https://docs.bettertoken.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# BetterToken के साथ OpenAI और Anthropic SDK चलाएँ

> BetterToken के लिए OpenAI SDK का Base URL और Anthropic SDK का base_url सेट करें। Python, JavaScript व curl से टेक्स्ट API के उदाहरण चलाएं।

OpenAI SDK के लिए Base URL `https://bettertoken.ai/v1` और Anthropic SDK के लिए `https://bettertoken.ai` इस्तेमाल करें। नीचे दिए गए उदाहरण आपकी BetterToken API Key से Chat Completions, Responses या Messages पर छोटा टेक्स्ट अनुरोध भेजते हैं।

## SDK और Base URL चुनें

| API | SDK | Base URL | भेजा जाने वाला प्रमाणीकरण हेडर | संदर्भ |
| - | - | - | - | - |
| Chat Completions | OpenAI | `https://bettertoken.ai/v1` | `Authorization: Bearer YOUR_API_KEY` | [Chat Completions संदर्भ](/hi/api-reference/chat-completions.md) |
| Responses | OpenAI | `https://bettertoken.ai/v1` | `Authorization: Bearer YOUR_API_KEY` | [Responses संदर्भ](/hi/api-reference/responses.md) |
| Messages | Anthropic | `https://bettertoken.ai`, बिना `/v1` के | `x-api-key: YOUR_API_KEY` | [Messages](/hi/api-reference/messages.md) |

SDK एंडपॉइंट का पथ और प्रमाणीकरण हेडर जोड़ता है। Anthropic SDK API संस्करण का हेडर भी भेजता है। मौजूदा कोड बदल रहे हों तो [प्रोटोकॉल की तुलना](/hi/faq/concepts/openai-compatible-vs-anthropic-compatible.md) देखें।

## आवश्यकताएँ

[त्वरित शुरुआत](/hi/quickstart.md) पूरी करके BetterToken API Key बनाएँ और बैलेंस जोड़ें। [model plaza](https://bettertoken.ai/pricing) से ऐसी Model ID कॉपी करें जो आपके चुने हुए एंडपॉइंट पर उपलब्ध हो। अनुरोध चलाने से पहले नीचे दोनों प्लेसहोल्डर बदलें।

जिस टर्मिनल में उदाहरण चलाएँगे, उसमें ये वेरिएबल सेट करें। इस पेज की शेल कमांड macOS / Linux के लिए हैं:

```bash theme={null}
export BETTERTOKEN_API_KEY="YOUR_API_KEY"
export BETTERTOKEN_MODEL_ID="YOUR_MODEL_ID"
```

Python के लिए प्रोजेक्ट के वर्चुअल एनवायरनमेंट में SDK इंस्टॉल करें:

```bash theme={null}
python3 -m venv .venv
source .venv/bin/activate
python -m pip install openai anthropic
```

JavaScript के लिए प्रोजेक्ट में पैकेज इंस्टॉल करें। हर उदाहरण को अलग `.mjs` फ़ाइल में सहेजें और `node` से चलाएँ:

```bash theme={null}
npm install openai @anthropic-ai/sdk
```

सभी उदाहरण `BETTERTOKEN_API_KEY` से Key पढ़ते हैं। इनमें SDK के अपने पुनः प्रयास बंद हैं, ताकि एक परीक्षण अनजाने में कई प्रयासों में न बदल जाए। ऐप में पुनः प्रयास की नीति के लिए [त्रुटियाँ और सीमाएँ](/hi/api-reference/errors.md#retry-temporary-failures) देखें।

## Chat Completions कॉल करें

बातचीत का इनपुट `messages` में दें। सफल टेक्स्ट उत्तर में `choices[0].message.content` होता है।

**Python**

```python theme={null}
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["BETTERTOKEN_API_KEY"],
    base_url="https://bettertoken.ai/v1",
    timeout=120.0,
    max_retries=0,
)
response = client.chat.completions.create(
    model=os.environ["BETTERTOKEN_MODEL_ID"],
    messages=[{"role": "user", "content": "Reply with one word: OK"}],
)
print(response.choices[0].message.content)
```

**JavaScript**

```javascript theme={null}
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.BETTERTOKEN_API_KEY,
  baseURL: "https://bettertoken.ai/v1",
  timeout: 120000,
  maxRetries: 0,
});
const response = await client.chat.completions.create({
  model: process.env.BETTERTOKEN_MODEL_ID,
  messages: [{ role: "user", content: "Reply with one word: OK" }],
});
console.log(response.choices[0].message.content);
```

**curl**

```bash theme={null}
curl --fail-with-body --max-time 120 "https://bettertoken.ai/v1/chat/completions" \
  -H "Authorization: Bearer $BETTERTOKEN_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"model\":\"$BETTERTOKEN_MODEL_ID\",\"messages\":[{\"role\":\"user\",\"content\":\"Reply with one word: OK\"}]}"
```

## Responses कॉल करें

प्रॉम्प्ट के लिए `input` इस्तेमाल करें। OpenAI SDK टेक्स्ट आसानी से पढ़ने के लिए `output_text` प्रॉपर्टी देता है। HTTP के JSON उत्तर में `output` ऐरे होता है। हर आउटपुट आइटम को टेक्स्ट मानने के बजाय संदेश वाले आइटम और उनके टेक्स्ट की जाँच करें।

**Python**

```python theme={null}
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["BETTERTOKEN_API_KEY"],
    base_url="https://bettertoken.ai/v1",
    timeout=120.0,
    max_retries=0,
)
response = client.responses.create(
    model=os.environ["BETTERTOKEN_MODEL_ID"],
    input="Reply with one word: OK",
)
print(response.output_text)
```

**JavaScript**

```javascript theme={null}
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.BETTERTOKEN_API_KEY,
  baseURL: "https://bettertoken.ai/v1",
  timeout: 120000,
  maxRetries: 0,
});
const response = await client.responses.create({
  model: process.env.BETTERTOKEN_MODEL_ID,
  input: "Reply with one word: OK",
});
console.log(response.output_text);
```

**curl**

```bash theme={null}
curl --fail-with-body --max-time 120 "https://bettertoken.ai/v1/responses" \
  -H "Authorization: Bearer $BETTERTOKEN_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"model\":\"$BETTERTOKEN_MODEL_ID\",\"input\":\"Reply with one word: OK\"}"
```

## Messages कॉल करें

`messages` इस्तेमाल करें और `max_tokens` दें। इस छोटे टेक्स्ट अनुरोध के सफल उत्तर में `content[0].text` जैसा टेक्स्ट ब्लॉक होता है। सामान्य तौर पर `content` के सभी ब्लॉक देखें और केवल `type: "text"` वाले ब्लॉक पढ़ें।

**Python**

```python theme={null}
import os
from anthropic import Anthropic

client = Anthropic(
    api_key=os.environ["BETTERTOKEN_API_KEY"],
    base_url="https://bettertoken.ai",
    timeout=120.0,
    max_retries=0,
)
response = client.messages.create(
    model=os.environ["BETTERTOKEN_MODEL_ID"],
    max_tokens=256,
    messages=[{"role": "user", "content": "Reply with one word: OK"}],
)
for block in response.content:
    if block.type == "text":
        print(block.text)
```

**JavaScript**

```javascript theme={null}
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.BETTERTOKEN_API_KEY,
  baseURL: "https://bettertoken.ai",
  timeout: 120000,
  maxRetries: 0,
});
const response = await client.messages.create({
  model: process.env.BETTERTOKEN_MODEL_ID,
  max_tokens: 256,
  messages: [{ role: "user", content: "Reply with one word: OK" }],
});
for (const block of response.content) {
  if (block.type === "text") console.log(block.text);
}
```

**curl**

```bash theme={null}
curl --fail-with-body --max-time 120 "https://bettertoken.ai/v1/messages" \
  -H "x-api-key: $BETTERTOKEN_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d "{\"model\":\"$BETTERTOKEN_MODEL_ID\",\"max_tokens\":256,\"messages\":[{\"role\":\"user\",\"content\":\"Reply with one word: OK\"}]}"
```

## उपलब्ध मॉडल की सूची प्राप्त करें

`Authorization: Bearer` या `x-api-key` प्रमाणीकरण के साथ `GET https://bettertoken.ai/v1/models` भेजें। सफल उत्तर HTTP `200` लौटाता है और उसके शीर्ष स्तर पर `data`, `object` और `success` फ़ील्ड होते हैं। `data` की हर प्रविष्टि में `id`, `object`, `created`, `owned_by` और `supported_endpoint_types` होते हैं।

**curl**

```bash theme={null}
curl --fail-with-body --max-time 120 "https://bettertoken.ai/v1/models" \
  -H "Authorization: Bearer $BETTERTOKEN_API_KEY"
```

`x-api-key` इस्तेमाल करने के लिए प्रमाणीकरण हेडर को `-H "x-api-key: $BETTERTOKEN_API_KEY"` से बदलें।

**Python**

```python theme={null}
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["BETTERTOKEN_API_KEY"],
    base_url="https://bettertoken.ai/v1",
    timeout=120.0,
    max_retries=0,
)
for model in client.models.list():
    print(model.id)
```

उत्तर में मिले `id` को अनुरोध के `model` में इस्तेमाल करें। `type` या `display_name` को आवश्यक न मानें; ये फ़ील्ड हर प्रविष्टि में नहीं होते। मॉडल चुनने के लिए `id` का इस्तेमाल करें और मौजूदा कीमतों व मॉडल के पूरे विवरण के लिए [model plaza](https://bettertoken.ai/pricing) देखें।

## सामान्य त्रुटियाँ

| लक्षण | जाँच और समाधान |
| - | - |
| गलत URL या `404` | OpenAI SDK के Base URL में `/v1` होता है, Anthropic SDK में नहीं। SDK के Base URL में अंतिम रूट न जोड़ें। |
| `401` या प्रमाणीकरण जानकारी न मिलना | उदाहरण `BETTERTOKEN_API_KEY` से Key स्पष्ट रूप से पास करते हैं। सीधे OpenAI अनुरोध में Bearer और सीधे Messages अनुरोध में `x-api-key` इस्तेमाल करें। |
| मॉडल न मिलना | `YOUR_MODEL_ID` की जगह model plaza से उपलब्ध मॉडल की सही Model ID दें। चुने हुए एंडपॉइंट के लिए भी इसकी उपलब्धता जाँचें। |
| अनुरोध पुराने एंडपॉइंट पर पहुँचना | SDK के आर्ग्युमेंट और पहले से मिले वेरिएबल जाँचें। [टकराने वाले एनवायरनमेंट वेरिएबल हटाना](/hi/best-practices.md#clear-conflicting-environment-variables) देखें। |
| खाली टेक्स्ट या अधूरा उत्तर | पूरा उत्तर और रुकने का कारण देखें। [आउटपुट टोकन सीमा](/hi/faq/model-calling/max-tokens.md) जाँचें। |

### क्या दोनों SDK में एक ही Key इस्तेमाल कर सकते हैं?

हाँ। एक BetterToken API Key सभी उपलब्ध मॉडल के साथ काम करती है। हर SDK के लिए सही Base URL और अनुरोध का फ़ॉर्मैट इस्तेमाल करें।

### क्या स्ट्रीमिंग, टूल या संरचित आउटपुट जोड़ सकते हैं?

स्ट्रीमिंग और टूल कॉलिंग का समर्थन मॉडल के अनुसार बदलता है। पहले अपनी Model ID से छोटा अनुरोध जाँचें, फिर [स्ट्रीमिंग और टूल कॉलिंग](/hi/guides/streaming-and-tool-calling.md) गाइड अपनाएँ। JSON की जाँच और मॉडल के अनुसार उपलब्ध संरचित आउटपुट के लिए [संरचित JSON से जुड़े प्रश्न](/hi/faq/model-calling/structured-json-pydantic.md) देखें।

## संबंधित गाइड

* [API संदर्भ का परिचय](/hi/api-reference/introduction.md)
* [समर्थित टूल](/hi/ai-tools/overview.md)
* [त्रुटियाँ, स्टेटस कोड और अनुरोध दर की सीमाएँ](/hi/api-reference/errors.md)
* [API Key की सुरक्षा और टाइमआउट](/hi/best-practices.md)
* [कैश की बिलिंग के नियम](/hi/faq/service-assurance/cache-billing.md)

## आधिकारिक संदर्भ

* [OpenAI Python SDK की आधिकारिक रिपॉज़िटरी](https://github.com/openai/openai-python)
* [OpenAI JavaScript SDK की आधिकारिक रिपॉज़िटरी](https://github.com/openai/openai-node)
* [Anthropic Python SDK की आधिकारिक रिपॉज़िटरी](https://github.com/anthropics/anthropic-sdk-python)
* [Anthropic JavaScript SDK की आधिकारिक रिपॉज़िटरी](https://github.com/anthropics/anthropic-sdk-typescript)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.