> ## 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 de OpenAI y Anthropic: ejemplos con BetterToken

> Configura los SDK de OpenAI y Anthropic con BetterToken. Ejemplos en Python, JavaScript y curl con Base URL, autenticación y tres endpoints de texto.

Usa el SDK de OpenAI con la Base URL `https://bettertoken.ai/v1` o el SDK de Anthropic con `https://bettertoken.ai`. Los ejemplos envían una solicitud breve de texto a Chat Completions, Responses o Messages con tu BetterToken API Key.

## Elige un SDK y una Base URL

| API | SDK | Base URL | Autenticación HTTP | Referencia |
| - | - | - | - | - |
| Chat Completions | OpenAI | `https://bettertoken.ai/v1` | `Authorization: Bearer YOUR_API_KEY` | [Referencia de Chat Completions](/es/api-reference/chat-completions.md) |
| Responses | OpenAI | `https://bettertoken.ai/v1` | `Authorization: Bearer YOUR_API_KEY` | [Responses](/es/api-reference/responses.md) |
| Messages | Anthropic | `https://bettertoken.ai`, sin `/v1` | `x-api-key: YOUR_API_KEY` | [Messages](/es/api-reference/messages.md) |

El SDK añade la ruta del endpoint y las cabeceras de autenticación. El SDK de Anthropic también envía la cabecera de versión de la API. Si adaptas código existente, consulta la [comparación de protocolos](/es/faq/concepts/openai-compatible-vs-anthropic-compatible.md).

## Requisitos previos

Completa la [guía de inicio rápido](/es/quickstart.md) para crear una BetterToken API Key y recargar el saldo. Copia del [model plaza](https://bettertoken.ai/pricing) un Model ID disponible para el endpoint que vas a usar. Sustituye los dos valores de ejemplo antes de enviar una solicitud.

Define estas variables en el terminal donde ejecutarás los ejemplos. Los comandos de esta página usan la sintaxis de macOS / Linux:

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

Para Python, instala los SDK en el entorno virtual de tu proyecto:

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

Para JavaScript, instala los paquetes en tu proyecto, guarda cada ejemplo en un archivo `.mjs` independiente y ejecútalo con `node`:

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

Todos los ejemplos leen la Key de `BETTERTOKEN_API_KEY`. Desactivan los reintentos del SDK para que una prueba no genere varios intentos sin que lo adviertas. Para definir la política de reintentos de tu aplicación, consulta [errores y límites](/es/api-reference/errors.md#retry-temporary-failures).

## Llama a Chat Completions

Usa `messages` para la conversación de entrada. Una respuesta de texto correcta contiene `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\"}]}"
```

## Llama a Responses

Usa `input` para el mensaje de entrada. Los SDK de OpenAI ofrecen la propiedad `output_text` para acceder al texto; la respuesta HTTP en JSON contiene un array `output`. Revisa los elementos de tipo mensaje y su contenido de texto, sin asumir que todos los elementos de salida son texto.

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

## Llama a Messages

Usa `messages` e incluye `max_tokens`. En esta solicitud breve, una respuesta de texto correcta incluye un bloque de texto como `content[0].text`. En general, recorre `content` y lee solo los bloques con `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\"}]}"
```

## Lista los modelos disponibles

Envía `GET https://bettertoken.ai/v1/models` con autenticación `Authorization: Bearer` o `x-api-key`. Una respuesta correcta devuelve HTTP `200` con los campos `data`, `object` y `success` en el nivel superior. Cada entrada de `data` incluye `id`, `object`, `created`, `owned_by` y `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"
```

Para usar `x-api-key`, sustituye la cabecera de autenticación por `-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)
```

Usa uno de los valores `id` devueltos como `model` en tu solicitud. No dependas de `type` ni de `display_name`, ya que no aparecen en todas las entradas. Selecciona el modelo por su `id` y consulta los precios actuales y las descripciones completas en la [model plaza](https://bettertoken.ai/pricing).

## Errores frecuentes

| Síntoma | Comprobación y solución |
| - | - |
| URL incorrecta o `404` | La Base URL del SDK de OpenAI incluye `/v1`; la del SDK de Anthropic no. No añadas la ruta final a la Base URL de un SDK. |
| `401` o credencial ausente | Los ejemplos pasan la Key explícitamente desde `BETTERTOKEN_API_KEY`. Las solicitudes directas a OpenAI usan Bearer; las de Messages usan `x-api-key`. |
| Modelo no encontrado | Sustituye `YOUR_MODEL_ID` por un Model ID exacto y disponible del model plaza. Comprueba que funcione con el endpoint elegido. |
| Las solicitudes llegan a un endpoint anterior | Revisa los argumentos del SDK y las variables heredadas; consulta [eliminar variables de entorno en conflicto](/es/best-practices.md#clear-conflicting-environment-variables). |
| Texto vacío o respuesta incompleta | Revisa la respuesta completa y el motivo de finalización; consulta los [límites de tokens de salida](/es/faq/model-calling/max-tokens.md). |

### ¿Puedo usar la misma Key con ambos SDK?

Sí. Una BetterToken API Key funciona con todos los modelos disponibles. Usa la Base URL y el formato de solicitud de cada SDK.

### ¿Puedo añadir streaming, herramientas o salida estructurada?

La compatibilidad con streaming y llamadas a herramientas varía según el modelo. Prueba primero una solicitud pequeña con tu Model ID; sigue la [guía de streaming y llamadas a herramientas](/es/guides/streaming-and-tool-calling.md). Para validar JSON y usar salida estructurada según el modelo, consulta las [preguntas sobre JSON estructurado](/es/faq/model-calling/structured-json-pydantic.md).

## Recursos relacionados

* [Introducción a la referencia de la API](/es/api-reference/introduction.md)
* [Herramientas compatibles](/es/ai-tools/overview.md)
* [Errores, códigos de estado y límites de solicitudes](/es/api-reference/errors.md)
* [Seguridad de la API Key y tiempos de espera](/es/best-practices.md)
* [Reglas de facturación de la caché](/es/faq/service-assurance/cache-billing.md)

## Referencias oficiales

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


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