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

# SDKs OpenAI e Anthropic: exemplos com BetterToken

> Configure os SDKs OpenAI e Anthropic no BetterToken. Use exemplos em Python, JavaScript e curl com Base URL, autenticação e três endpoints de texto.

Use o SDK da OpenAI com a Base URL `https://bettertoken.ai/v1` ou o SDK da Anthropic com `https://bettertoken.ai`. Os exemplos enviam uma solicitação curta de texto por Chat Completions, Responses ou Messages usando sua BetterToken API Key.

## Escolha o SDK e a Base URL

| API | SDK | Base URL | Autenticação HTTP | Referência |
| - | - | - | - | - |
| Chat Completions | OpenAI | `https://bettertoken.ai/v1` | `Authorization: Bearer YOUR_API_KEY` | [Referência de Chat Completions](/pt-br/api-reference/chat-completions.md) |
| Responses | OpenAI | `https://bettertoken.ai/v1` | `Authorization: Bearer YOUR_API_KEY` | [Responses](/pt-br/api-reference/responses.md) |
| Messages | Anthropic | `https://bettertoken.ai`, sem `/v1` | `x-api-key: YOUR_API_KEY` | [Messages](/pt-br/api-reference/messages.md) |

O SDK adiciona o caminho do endpoint e os cabeçalhos de autenticação. O SDK da Anthropic também envia o cabeçalho de versão da API. Se estiver adaptando código existente, consulte a [comparação de protocolos](/pt-br/faq/concepts/openai-compatible-vs-anthropic-compatible.md).

## Pré-requisitos

Conclua o [início rápido](/pt-br/quickstart.md) para criar uma BetterToken API Key e adicionar saldo. Copie da [model plaza](https://bettertoken.ai/pricing) um Model ID disponível para o endpoint que você vai chamar. Substitua os dois valores de exemplo antes de enviar uma solicitação.

Defina estas variáveis no terminal em que executará os exemplos. Os comandos desta página usam a sintaxe do macOS / Linux:

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

Para Python, instale os SDKs no ambiente virtual do seu projeto:

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

Para JavaScript, instale os pacotes no projeto, salve cada exemplo em um arquivo `.mjs` separado e execute-o com `node`:

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

Todos os exemplos leem a Key de `BETTERTOKEN_API_KEY`. Eles desativam as novas tentativas do SDK para que um teste não gere várias tentativas sem aviso. Para definir a política de novas tentativas da aplicação, consulte [erros e limites](/pt-br/api-reference/errors.md#retry-temporary-failures).

## Chame Chat Completions

Use `messages` para a conversa de entrada. Uma resposta de texto bem-sucedida contém `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\"}]}"
```

## Chame Responses

Use `input` para o prompt. Os SDKs da OpenAI oferecem a propriedade `output_text` para facilitar o acesso ao texto; a resposta HTTP em JSON contém um array `output`. Verifique os itens de mensagem e seu conteúdo de texto, sem presumir que todos os itens de saída sejam 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\"}"
```

## Chame Messages

Use `messages` e informe `max_tokens`. Nesta solicitação curta, uma resposta de texto bem-sucedida inclui um bloco como `content[0].text`. Em geral, percorra `content` e leia apenas os blocos com `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\"}]}"
```

## Liste os modelos disponíveis

Envie `GET https://bettertoken.ai/v1/models` com autenticação `Authorization: Bearer` ou `x-api-key`. Uma resposta bem-sucedida retorna HTTP `200` com os campos `data`, `object` e `success` no nível superior. Cada entrada de `data` inclui `id`, `object`, `created`, `owned_by` e `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`, substitua o cabeçalho de autenticação 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)
```

Use um dos valores `id` retornados como `model` na solicitação. Não dependa de `type` nem de `display_name`, pois esses campos não aparecem em todas as entradas. Selecione o modelo pelo `id` e consulte os preços atuais e as descrições completas na [model plaza](https://bettertoken.ai/pricing).

## Erros comuns

| Sintoma | Verificação e correção |
| - | - |
| URL incorreta ou `404` | A Base URL do SDK da OpenAI inclui `/v1`; a do SDK da Anthropic não. Não acrescente a rota final à Base URL de um SDK. |
| `401` ou credencial ausente | Os exemplos passam a Key explicitamente a partir de `BETTERTOKEN_API_KEY`. Solicitações diretas à OpenAI usam Bearer; solicitações diretas a Messages usam `x-api-key`. |
| Modelo não encontrado | Substitua `YOUR_MODEL_ID` por um Model ID exato e disponível na model plaza. Verifique a disponibilidade no endpoint escolhido. |
| As solicitações chegam a um endpoint antigo | Verifique os argumentos do SDK e as variáveis herdadas; consulte [remover variáveis de ambiente conflitantes](/pt-br/best-practices.md#clear-conflicting-environment-variables). |
| Texto vazio ou resposta incompleta | Examine a resposta completa e o motivo de encerramento; consulte os [limites de tokens de saída](/pt-br/faq/model-calling/max-tokens.md). |

### Posso usar a mesma Key nos dois SDKs?

Sim. Uma BetterToken API Key funciona com todos os modelos disponíveis. Use a Base URL e o formato de solicitação de cada SDK.

### Posso adicionar streaming, ferramentas ou saída estruturada?

O suporte a streaming e chamadas de ferramentas varia conforme o modelo. Teste primeiro uma solicitação pequena com seu Model ID; siga o guia de [streaming e chamadas de ferramentas](/pt-br/guides/streaming-and-tool-calling.md). Para validação de JSON e saída estruturada conforme o modelo, consulte as [perguntas sobre JSON estruturado](/pt-br/faq/model-calling/structured-json-pydantic.md).

## Conteúdo relacionado

* [Visão geral da referência da API](/pt-br/api-reference/introduction.md)
* [Ferramentas compatíveis](/pt-br/ai-tools/overview.md)
* [Erros, códigos de status e limites de requisições](/pt-br/api-reference/errors.md)
* [Segurança da API Key e tempos limite](/pt-br/best-practices.md)
* [Regras de cobrança de cache](/pt-br/faq/service-assurance/cache-billing.md)

## Referências oficiais

* [SDK da OpenAI para Python](https://github.com/openai/openai-python)
* [SDK da OpenAI para JavaScript](https://github.com/openai/openai-node)
* [SDK da Anthropic para Python](https://github.com/anthropics/anthropic-sdk-python)
* [SDK da 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.