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

# OpenAI- und Anthropic-SDKs mit BetterToken nutzen

> Richte die OpenAI- und Anthropic-SDKs für BetterToken ein. Beispiele für Python, JavaScript und curl zeigen Base URL, Authentifizierung und Textanfragen.

Nutze das OpenAI-SDK mit der Base URL `https://bettertoken.ai/v1` oder das Anthropic-SDK mit `https://bettertoken.ai`. Die Beispiele senden mit deinem BetterToken API Key eine kurze Textanfrage über Chat Completions, Responses oder Messages.

## SDK und Base URL wählen

| API | SDK | Base URL | Authentifizierung per HTTP | Referenz |
| - | - | - | - | - |
| Chat Completions | OpenAI | `https://bettertoken.ai/v1` | `Authorization: Bearer YOUR_API_KEY` | [Referenz für Chat Completions](/de/api-reference/chat-completions.md) |
| Responses | OpenAI | `https://bettertoken.ai/v1` | `Authorization: Bearer YOUR_API_KEY` | [Responses](/de/api-reference/responses.md) |
| Messages | Anthropic | `https://bettertoken.ai`, ohne `/v1` | `x-api-key: YOUR_API_KEY` | [Messages](/de/api-reference/messages.md) |

Das SDK ergänzt den Endpunktpfad und die Authentifizierungsheader. Das Anthropic-SDK sendet außerdem den Header für die API-Version. Wenn du bestehenden Code anpasst, hilft der [Protokollvergleich](/de/faq/concepts/openai-compatible-vs-anthropic-compatible.md).

## Voraussetzungen

Folge dem [Schnellstart](/de/quickstart.md), um einen BetterToken API Key zu erstellen und Guthaben aufzuladen. Kopiere aus der [model plaza](https://bettertoken.ai/pricing) eine Model ID, die für den gewünschten Endpunkt verfügbar ist. Ersetze beide Platzhalter, bevor du eine Anfrage sendest.

Setze diese Variablen in dem Terminal, in dem du die Beispiele ausführst. Die Shell-Befehle auf dieser Seite verwenden die Syntax für macOS / Linux:

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

Installiere die SDKs für Python in der virtuellen Umgebung deines Projekts:

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

Installiere für JavaScript die Pakete im Projekt. Speichere jedes Beispiel in einer eigenen `.mjs`-Datei und führe es mit `node` aus:

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

Alle Beispiele lesen den Key aus `BETTERTOKEN_API_KEY`. Sie deaktivieren SDK-Wiederholungen, damit ein Test nicht unbemerkt mehrere Versuche auslöst. Hinweise zu Wiederholungsregeln für deine Anwendung findest du unter [Fehler und Limits](/de/api-reference/errors.md#retry-temporary-failures).

## Chat Completions aufrufen

Verwende `messages` für die Eingabekonversation. Eine erfolgreiche Textantwort enthält `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 aufrufen

Verwende `input` für den Prompt. Die OpenAI-SDKs stellen mit `output_text` eine Eigenschaft für den bequemen Textzugriff bereit; die HTTP-Antwort im JSON-Format enthält ein `output`-Array. Prüfe die Nachrichtenelemente und deren Textinhalt, statt für jedes Ausgabeelement Text vorauszusetzen.

**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 aufrufen

Verwende `messages` und gib `max_tokens` an. Bei dieser kurzen Textanfrage enthält eine erfolgreiche Antwort einen Textblock wie `content[0].text`. Durchlaufe grundsätzlich `content` und lies nur Blöcke mit `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\"}]}"
```

## Verfügbare Modelle auflisten

Sende `GET https://bettertoken.ai/v1/models` mit Authentifizierung über `Authorization: Bearer` oder `x-api-key`. Eine erfolgreiche Antwort liefert HTTP `200` mit den Feldern `data`, `object` und `success` auf oberster Ebene. Jeder Eintrag in `data` enthält `id`, `object`, `created`, `owned_by` und `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"
```

Um `x-api-key` zu verwenden, ersetze den Authentifizierungsheader durch `-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)
```

Verwende einen zurückgegebenen `id`-Wert als `model` in deiner Anfrage. Setze `type` und `display_name` nicht voraus, da diese Felder nicht in jedem Eintrag vorhanden sind. Wähle das Modell anhand von `id` aus und nutze die [model plaza](https://bettertoken.ai/pricing) für aktuelle Preise und vollständige Modellbeschreibungen.

## Häufige Fehler

| Symptom | Prüfung und Lösung |
| - | - |
| Falsche URL oder `404` | Die Base URL des OpenAI-SDKs enthält `/v1`, die des Anthropic-SDKs nicht. Hänge die endgültige Route nicht an die Base URL eines SDKs an. |
| `401` oder fehlende Zugangsdaten | Die Beispiele übergeben den Key ausdrücklich aus `BETTERTOKEN_API_KEY`. Direkte OpenAI-Anfragen verwenden Bearer, direkte Messages-Anfragen `x-api-key`. |
| Modell nicht gefunden | Ersetze `YOUR_MODEL_ID` durch eine exakte, verfügbare Model ID aus der model plaza. Prüfe sie für den gewählten Endpunkt. |
| Anfragen erreichen einen alten Endpunkt | Prüfe SDK-Argumente und geerbte Variablen; siehe [konfligierende Umgebungsvariablen löschen](/de/best-practices.md#clear-conflicting-environment-variables). |
| Leerer Text oder unvollständige Antwort | Prüfe die vollständige Antwort und den Abbruchgrund; siehe [Limits für Ausgabetokens](/de/faq/model-calling/max-tokens.md). |

### Kann ich denselben Key für beide SDKs verwenden?

Ja. Ein BetterToken API Key funktioniert mit allen verfügbaren Modellen. Verwende für jedes SDK die passende Base URL und das passende Anfrageformat.

### Kann ich Streaming, Tools oder strukturierte Ausgaben ergänzen?

Die Unterstützung für Streaming und Tool-Aufrufe hängt vom Modell ab. Teste zunächst eine kleine Anfrage mit deiner Model ID; nutze die Anleitung zu [Streaming und Tool-Aufrufen](/de/guides/streaming-and-tool-calling.md). Für JSON-Validierung und modellabhängige strukturierte Ausgaben hilft die [FAQ zu strukturiertem JSON](/de/faq/model-calling/structured-json-pydantic.md).

## Weitere Informationen

* [Übersicht der API-Referenz](/de/api-reference/introduction.md)
* [Unterstützte Tools](/de/ai-tools/overview.md)
* [Fehler, Statuscodes und Anfragelimits](/de/api-reference/errors.md)
* [API-Key-Sicherheit und Timeouts](/de/best-practices.md)
* [Regeln zur Cache-Abrechnung](/de/faq/service-assurance/cache-billing.md)

## Offizielle Referenzen

* [OpenAI-SDK für Python](https://github.com/openai/openai-python)
* [OpenAI-SDK für JavaScript](https://github.com/openai/openai-node)
* [Anthropic-SDK für Python](https://github.com/anthropics/anthropic-sdk-python)
* [Anthropic-SDK für JavaScript](https://github.com/anthropics/anthropic-sdk-typescript)


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