# Endpoint de chat completions: POST /api/v1/chat/completions

> Endpoint de chat completions: campos do body de POST /api/v1/chat/completions, a resposta, os motivos de término e o uso de tokens. Compatível com OpenAI.

- URL: https://llmwithcrypto.com/pt/docs/chat-completions/
- Última atualização: 2026-10-23
- Editor: LLMwithCrypto (https://llmwithcrypto.com)

Um único endpoint responde por todos os modelos. Ele recebe o mesmo body da API de chat completions da OpenAI e retorna o mesmo objeto, então uma integração existente só precisa de uma nova base URL, uma nova chave e um id de modelo da nossa lista.

**Resposta rápida — Quais campos o endpoint de chat completions do LLMwithCrypto aceita?**

Ele aceita o body de chat completions da OpenAI: `model` e `messages` são obrigatórios; `max_tokens`, `temperature`, `top_p`, `stop`, `stream`, `stream_options`, `tools`, `tool_choice` e `response_format` são opcionais. **LLMwithCrypto** retorna um objeto `chat.completion` com a contagem de `usage`, cobrada por token a partir do seu crédito, conforme documentado em 23 de outubro de 2026. Tool calling e saída JSON dependem do modelo.

## O endpoint em resumo

| Atributo | Valor |
| --- | --- |
| Método e URL | `POST https://llmwithcrypto.com/api/v1/chat/completions` |
| Autenticação | Passe sua chave de API como Bearer token no header Authorization, como o SDK da OpenAI faz |
| Body | JSON, `Content-Type: application/json` |
| Resposta | Objeto `chat.completion`, ou server-sent events com `stream: true` |
| Cobrança | Você paga por token a partir do seu saldo: tokens de entrada e de saída são contados pelo tokenizer do próprio modelo e cobrados ao preço daquele modelo por 1M de tokens. Uma chamada que termina em erro não custa nada |
| Recursos | O streaming funciona em todos os modelos; tool calling e saída em JSON seguem o que cada modelo suporta por si |

## Criar uma chat completion

`POST /api/v1/chat/completions`

Envia uma conversa para um modelo e retorna a resposta com as contagens de tokens. O exemplo faz uma pergunta curta ao DeepSeek V4 Pro com limite de 200 tokens; ids, horários e contagens na resposta são ilustrativos.

Autenticação: chave de API no cabeçalho `Authorization: Bearer API_KEY`.

**Corpo da requisição**

| Campo | Tipo | Obrigatório | Descrição |
| --- | --- | --- | --- |
| `model` | string | Sim | O id do modelo, como `deepseek-v4-pro` ou `gpt-oss-120b`. `GET /api/v1/models` retorna todos os ids que sua chave pode chamar. |
| `messages` | object[] | Sim | A conversa, da mensagem mais antiga para a mais recente. Cada item tem um `role` (`system`, `user`, `assistant` ou `tool`) e uma string `content`; mensagens `tool` também carregam um `tool_call_id`. |
| `max_tokens` | integer | Não | O número máximo de tokens que a resposta pode usar. Sem isso, o modelo pode escrever até encher a janela de contexto, e você paga por cada token que ele escrever. |
| `temperature` | number | Não | 0 a 2. Mais baixo é mais previsível, mais alto é mais variado. O padrão depende do modelo. |
| `top_p` | number | Não | 0 a 1, amostragem nucleus. Altere `temperature` ou `top_p`, não ambos. |
| `stop` | string or string[] | Não | Até 4 sequências que encerram a resposta quando o modelo as escreve. Elas não são incluídas na resposta. |
| `stream` | boolean | Não | `true` envia a resposta como server-sent events, peça por peça. Veja [streaming](https://llmwithcrypto.com/pt/docs/streaming/). |
| `stream_options` | object | Não | `{"include_usage": true}` adiciona um último evento com o `usage` de uma chamada em streaming. |
| `tools` | object[] | Não | Funções que o modelo pode pedir para você chamar, no formato da OpenAI. Funciona nos modelos que suportam tool calling. Veja [tool calling](https://llmwithcrypto.com/pt/docs/tool-calling/). |
| `tool_choice` | string or object | Não | `auto` (padrão quando `tools` está definido), `none`, `required` ou `{"type": "function", "function": {"name": "…"}}`. |
| `response_format` | object | Não | `{"type": "json_object"}` pede um objeto JSON válido, nos modelos que suportam isso. Diga no seu prompt o que o JSON deve conter. |

*Exemplo: a short answer from DeepSeek V4 Pro*

```json
{
  "model": "deepseek-v4-pro",
  "messages": [
    {
      "role": "system",
      "content": "Answer in two sentences."
    },
    {
      "role": "user",
      "content": "What is a context window?"
    }
  ],
  "max_tokens": 200
}
```

*Exemplo: a JSON object from gpt-oss-120b, low temperature*

```json
{
  "model": "gpt-oss-120b",
  "messages": [
    {
      "role": "user",
      "content": "Return {\"city\": string, \"country\": string} for the Eiffel Tower."
    }
  ],
  "response_format": {
    "type": "json_object"
  },
  "temperature": 0.2,
  "max_tokens": 100
}
```

**Resposta** `200`

```json
{
  "id": "chatcmpl-8f2c41d0a7b94e1c",
  "object": "chat.completion",
  "created": 1792742400,
  "model": "deepseek-v4-pro",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "A context window is the maximum number of tokens a model can read and write in one request. Anything beyond it must be cut or summarized before the call."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 27,
    "completion_tokens": 34,
    "total_tokens": 61
  }
}
```

*curl*

```bash
curl -s "https://llmwithcrypto.com/api/v1/chat/completions" \
  -H "Authorization: Bearer $LLMWITHCRYPTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [
      {"role": "system", "content": "Answer in two sentences."},
      {"role": "user", "content": "What is a context window?"}
    ],
    "max_tokens": 200
  }'
```

*Python*

```python
import os

from openai import OpenAI

client = OpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)

resp = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "Answer in two sentences."},
        {"role": "user", "content": "What is a context window?"},
    ],
    max_tokens=200,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, "in,", resp.usage.completion_tokens, "out")
```

*Node.js*

```javascript
import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://llmwithcrypto.com/api/v1',
  apiKey: process.env.LLMWITHCRYPTO_API_KEY,
});

const resp = await client.chat.completions.create({
  model: 'deepseek-v4-pro',
  messages: [
    { role: 'system', content: 'Answer in two sentences.' },
    { role: 'user', content: 'What is a context window?' },
  ],
  max_tokens: 200,
});
console.log(resp.choices[0].message.content);
console.log(resp.usage.prompt_tokens, 'in,', resp.usage.completion_tokens, 'out');
```

## Como escrevo as mensagens?

Envie a conversa inteira toda vez, da mensagem mais antiga para a mais recente: a API não guarda memória entre chamadas, e nada dos seus prompts é armazenado. Não armazenamos seus prompts nem as respostas do modelo: assim que uma resposta é enviada, o texto dela se vai. Cada chamada deixa uma linha de log com o horário, a conta, o modelo e as contagens de tokens, apagada após 30 dias.

- **`system`**: instruções que enquadram toda resposta, como tom, idioma ou formato de saída. Coloque uma no topo.
- **`user`**: o que a pessoa ou seu programa pede.
- **`assistant`**: as respostas anteriores do modelo, para que ele possa continuar a conversa.
- **`tool`**: o resultado de uma função que o modelo pediu para você executar, com o `tool_call_id` que ele forneceu.

Toda mensagem conta como tokens de entrada, então históricos longos custam mais a cada turno. Corte ou resuma os turnos antigos quando a conversa crescer.

## Qual é o tamanho máximo de uma requisição?

Entrada e saída juntas precisam caber na janela de contexto do modelo. Em 23 de outubro de 2026, o DeepSeek V4 Pro lê até 1M tokens, o gpt-oss-120b até 128K e o Qwen3 235B até 256K; a [página de modelos](https://llmwithcrypto.com/pt/models/) lista todos eles.

Uma requisição que não cabe volta como `400` com o código `context_length_exceeded` e não custa nada. Defina `max_tokens` para que o prompt mais a resposta mais longa que você aceita caibam na janela.

## O que finish_reason me diz?

| `finish_reason` | Significado | O que fazer |
| --- | --- | --- |
| `stop` | O modelo encerrou a resposta, ou escreveu uma das suas sequências de `stop` | Nada: a resposta está completa |
| `length` | A resposta atingiu `max_tokens` ou a janela de contexto | Aumente `max_tokens`, ou peça uma resposta mais curta |
| `tool_calls` | O modelo quer que você execute uma ou mais funções | Execute-as e envie os resultados de volta, veja [tool calling](https://llmwithcrypto.com/pt/docs/tool-calling/) |

## Quais parâmetros da OpenAI não são suportados?

Os campos da tabela acima são o contrato inteiro. Outros da API da OpenAI, como `n` (várias respostas por chamada), `logprobs`, `audio` ou entradas de imagem, não são suportados: envie apenas os campos listados aqui. Os modelos são de texto; nenhum deles recebe imagens por este endpoint.

O campo `model` só aceita os ids da nossa lista. Não vendemos acesso ao GPT, Claude, Gemini ou Grok: seus criadores proíbem a revenda de acesso à API sem a aprovação deles, e nós não temos essa aprovação.

## Chat completions: perguntas frequentes

### Existe um endpoint de completions legado?

Não. Só existe o formato chat; um único prompt é um array `messages` com uma mensagem `user`.

### Quanto custa uma chamada?

Você paga por token a partir do seu saldo: tokens de entrada e de saída são contados pelo tokenizer do próprio modelo e cobrados ao preço daquele modelo por 1M de tokens. Uma chamada que termina em erro não custa nada. Os preços por modelo estão na [página de preços](https://llmwithcrypto.com/pt/pricing/).

### Posso ver minhas requisições passadas?

Não, por design. Não armazenamos seus prompts nem as respostas do modelo: assim que uma resposta é enviada, o texto dela se vai. Cada chamada deixa uma linha de log com o horário, a conta, o modelo e as contagens de tokens, apagada após 30 dias.

### Por que minha resposta parou no meio?

`finish_reason` então é `length`: a resposta atingiu `max_tokens`. Aumente, dentro da janela de contexto do modelo.

---

LLMwithCrypto: O LLMwithCrypto é uma API de LLM compatível com OpenAI para modelos open-weight — DeepSeek V4 Pro, DeepSeek V4.1 Flash, DeepSeek R1, Qwen3.5 397B A17B, Qwen3 235B A22B Instruct, gpt-oss-120b, gpt-oss-20b, GLM-4.7, Llama 3.3 70B Instruct, Gemma 4 31B, Mistral Large 3, Mistral Small 4 — paga por token a partir de um saldo cripto pré-pago, a 5% abaixo do preço mediano dos hosts públicos. Sem KYC: sem documento de identidade, sem selfie, sem documentos. Prompts e respostas não são armazenados.
