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

# SDK OpenAI et Anthropic : exemples avec BetterToken

> Configurez les SDK OpenAI et Anthropic avec BetterToken. Exemples Python, JavaScript et curl : Base URL, authentification et trois endpoints de texte.

Utilisez le SDK OpenAI avec la Base URL `https://bettertoken.ai/v1`, ou le SDK Anthropic avec `https://bettertoken.ai`. Les exemples envoient une courte requête de texte via Chat Completions, Responses ou Messages avec votre BetterToken API Key.

## Choisir un SDK et une Base URL

| API | SDK | Base URL | Authentification HTTP | Référence |
| - | - | - | - | - |
| Chat Completions | OpenAI | `https://bettertoken.ai/v1` | `Authorization: Bearer YOUR_API_KEY` | [Référence Chat Completions](/fr/api-reference/chat-completions.md) |
| Responses | OpenAI | `https://bettertoken.ai/v1` | `Authorization: Bearer YOUR_API_KEY` | [Responses](/fr/api-reference/responses.md) |
| Messages | Anthropic | `https://bettertoken.ai`, sans `/v1` | `x-api-key: YOUR_API_KEY` | [Messages](/fr/api-reference/messages.md) |

Le SDK ajoute le chemin de l’endpoint et les en-têtes d’authentification. Le SDK Anthropic envoie aussi l’en-tête de version de l’API. Si vous adaptez du code existant, consultez la [comparaison des protocoles](/fr/faq/concepts/openai-compatible-vs-anthropic-compatible.md).

## Prérequis

Suivez le [démarrage rapide](/fr/quickstart.md) pour créer une BetterToken API Key et ajouter du crédit. Copiez depuis la [model plaza](https://bettertoken.ai/pricing) un Model ID disponible pour l’endpoint que vous comptez appeler. Remplacez les deux valeurs d’exemple avant d’envoyer une requête.

Définissez ces variables dans le terminal où vous exécuterez les exemples. Les commandes de cette page utilisent la syntaxe macOS / Linux :

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

Pour Python, installez les SDK dans l’environnement virtuel de votre projet :

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

Pour JavaScript, installez les paquets dans votre projet, enregistrez chaque exemple dans un fichier `.mjs` distinct, puis exécutez-le avec `node` :

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

Tous les exemples lisent la Key depuis `BETTERTOKEN_API_KEY`. Ils désactivent les nouvelles tentatives du SDK pour qu’un test ne déclenche pas plusieurs tentatives à votre insu. Pour définir la politique de votre application, consultez les [erreurs et limites](/fr/api-reference/errors.md#retry-temporary-failures).

## Appeler Chat Completions

Utilisez `messages` pour la conversation d’entrée. Une réponse de texte réussie contient `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\"}]}"
```

## Appeler Responses

Utilisez `input` pour le prompt. Les SDK OpenAI proposent la propriété `output_text` pour accéder au texte ; la réponse HTTP en JSON contient un tableau `output`. Examinez les éléments de type message et leur contenu textuel sans supposer que tous les éléments de sortie sont du texte.

**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\"}"
```

## Appeler Messages

Utilisez `messages` et fournissez `max_tokens`. Pour cette courte requête, une réponse de texte réussie comprend un bloc tel que `content[0].text`. De manière générale, parcourez `content` et ne lisez que les blocs avec `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\"}]}"
```

## Lister les modèles disponibles

Envoyez `GET https://bettertoken.ai/v1/models` avec une authentification `Authorization: Bearer` ou `x-api-key`. Une réponse réussie renvoie HTTP `200` avec les champs `data`, `object` et `success` au premier niveau. Chaque entrée de `data` comprend `id`, `object`, `created`, `owned_by` et `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"
```

Pour utiliser `x-api-key`, remplacez l’en-tête d’authentification par `-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)
```

Utilisez un `id` renvoyé comme valeur de `model` dans votre requête. N’exigez pas `type` ni `display_name` ; ces champs ne figurent pas dans toutes les entrées. Appuyez-vous sur `id` pour choisir le modèle et consultez la [model plaza](https://bettertoken.ai/pricing) pour les prix actuels et les descriptions complètes des modèles.

## Erreurs fréquentes

| Symptôme | Vérification et correction |
| - | - |
| URL incorrecte ou `404` | La Base URL du SDK OpenAI comprend `/v1` ; celle du SDK Anthropic ne le comprend pas. N’ajoutez pas la route finale à la Base URL d’un SDK. |
| `401` ou identifiant absent | Les exemples transmettent explicitement la Key depuis `BETTERTOKEN_API_KEY`. Les requêtes OpenAI directes utilisent Bearer ; les requêtes Messages directes utilisent `x-api-key`. |
| Modèle introuvable | Remplacez `YOUR_MODEL_ID` par un Model ID exact et disponible dans la model plaza. Vérifiez sa disponibilité pour l’endpoint choisi. |
| Les requêtes atteignent un ancien endpoint | Vérifiez les arguments du SDK et les variables héritées ; consultez [effacer les variables d’environnement en conflit](/fr/best-practices.md#clear-conflicting-environment-variables). |
| Texte vide ou réponse incomplète | Examinez la réponse complète et le motif d’arrêt ; consultez les [limites de tokens de sortie](/fr/faq/model-calling/max-tokens.md). |

### Puis-je utiliser la même Key avec les deux SDK ?

Oui. Une BetterToken API Key fonctionne avec tous les modèles disponibles. Utilisez la Base URL et le format de requête propres à chaque SDK.

### Puis-je ajouter le streaming, des outils ou une sortie structurée ?

La prise en charge du streaming et des appels d’outils varie selon le modèle. Testez d’abord une petite requête avec votre Model ID ; suivez le guide du [streaming et des appels d’outils](/fr/guides/streaming-and-tool-calling.md). Pour la validation JSON et la sortie structurée selon le modèle, consultez la [FAQ sur le JSON structuré](/fr/faq/model-calling/structured-json-pydantic.md).

## Ressources associées

* [Présentation de la référence API](/fr/api-reference/introduction.md)
* [Outils compatibles](/fr/ai-tools/overview.md)
* [Erreurs, codes de statut et limites de requêtes](/fr/api-reference/errors.md)
* [Sécurité de l’API Key et délais d’attente](/fr/best-practices.md)
* [Règles de facturation du cache](/fr/faq/service-assurance/cache-billing.md)

## Références officielles

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


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