# curl: a LLM API a partir do terminal

> Receitas de terminal para LLM API compatível com OpenAI: chat completion com curl e jq, requisição de arquivo, streaming, modelos e crédito.

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

Toda chamada é HTTPS simples com um corpo JSON, então curl basta para testar uma chave, comparar dois modelos ou fazer um script rápido. `jq` deixa o JSON legível; os dois vêm na maioria dos sistemas ou instalam com um comando.

**Resposta rápida — Como chamo LLMwithCrypto com curl?**

Envie um POST para `https://llmwithcrypto.com/api/v1/chat/completions` com `-H "Authorization: Bearer $LLMWITHCRYPTO_API_KEY"`, um content type JSON e um corpo contendo `model` e `messages`. **LLMwithCrypto** retorna o objeto de resposta da OpenAI; passe-o para `jq` para imprimir a resposta e as contagens de tokens. Adicione `-N` e `"stream": true` para ver o texto chegar ao vivo, conforme documentado em 23 de outubro de 2026.

## Como defino a chave uma vez só?

Exporte-a na sua sessão do shell para que todo comando possa usá-la, e mantenha-a fora do histórico do shell e de scripts compartilhados:

- **Linux e macOS:** `export LLMWITHCRYPTO_API_KEY=…` no terminal, ou em um arquivo `.env` que seus scripts carregam e que nunca é commitado.
- **Windows PowerShell:** `$env:LLMWITHCRYPTO_API_KEY = "…"`, depois rode os comandos no Git Bash ou WSL, ou adapte as aspas.

Crie uma chave de API por app, agente ou colega de equipe e revogue qualquer uma delas pelo dashboard sem mexer nas outras.

*Uma resposta curta e suas contagens de tokens*

```bash
curl -s "https://llmwithcrypto.com/api/v1/chat/completions" \
  -H "Authorization: Bearer $LLMWITHCRYPTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-oss-20b", "messages": [{"role": "user", "content": "One word for fast?"}], "max_tokens": 20}' \
  | jq -r '.choices[0].message.content, "\(.usage.prompt_tokens) in, \(.usage.completion_tokens) out"'

```

## Como evito problemas de aspas?

Coloque o corpo em um arquivo. Aspas do shell e aspas do JSON brigam assim que um prompt contém um apóstrofo ou um cifrão; um arquivo evita os dois. `--data @request.json` envia o arquivo como está.

*Uma requisição lida de um arquivo*

```bash
cat > request.json <<'EOF'
{
  "model": "deepseek-v4-pro",
  "messages": [
    {"role": "system", "content": "You review shell scripts."},
    {"role": "user", "content": "Is it safe to run rm -rf \"$DIR\"/ when DIR may be empty?"}
  ],
  "max_tokens": 300
}
EOF
curl -s "https://llmwithcrypto.com/api/v1/chat/completions" \
  -H "Authorization: Bearer $LLMWITHCRYPTO_API_KEY" \
  -H "Content-Type: application/json" \
  --data @request.json | jq -r '.choices[0].message.content'

```

## Como faço para acompanhar uma resposta transmitida em streaming?

`-N` desativa o buffer de saída do curl, então cada server-sent event é impresso assim que chega. Você verá linhas `data:` brutas; a [página de streaming](https://llmwithcrypto.com/pt/docs/streaming/) explica cada uma.

*Resposta em streaming, eventos brutos*

```bash
curl -sN "https://llmwithcrypto.com/api/v1/chat/completions" \
  -H "Authorization: Bearer $LLMWITHCRYPTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4.1-flash",
    "messages": [{"role": "user", "content": "Write a haiku about latency."}],
    "stream": true,
    "stream_options": {"include_usage": true},
    "max_tokens": 120
  }'

```

## Como faço para listar os modelos e conferir o crédito?

As duas chamadas são gratuitas. A primeira imprime um id de modelo por linha, pronto para o campo `model`; a segunda imprime o crédito restante em dólares.

*Ids de modelo*

```bash
curl -s "https://llmwithcrypto.com/api/v1/models" \
  -H "Authorization: Bearer $LLMWITHCRYPTO_API_KEY" | jq -r '.data[].id'

```

*Crédito restante*

```bash
curl -s "https://llmwithcrypto.com/api/v1/credits" \
  -H "Authorization: Bearer $LLMWITHCRYPTO_API_KEY" | jq -r '.balance_usd'

```

## Como faço para ver um erro no terminal?

Adicione `-w "\nHTTP %{http_code}\n"` para imprimir o status após o corpo. O corpo de um erro é um pequeno objeto JSON com um campo `code`, como `invalid_api_key`, `insufficient_balance` ou `model_not_found`; a [página de erros](https://llmwithcrypto.com/pt/docs/errors/) explica cada um. Com `jq`, `.error.code // empty` imprime o código quando existe e nada caso contrário, o que facilita criar ramificações em scripts.

Erros não custam nada. 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.

## Posso criar um script de lote com curl?

Para um punhado de requisições, um loop de shell sobre arquivos resolve: um corpo JSON por arquivo, um curl por arquivo, resultados gravados ao lado deles. Mantenha sequencial ou rode alguns por vez com `xargs -P 4`, para ficar abaixo do seu rate limit. Toda conta tem um limite de requisições e de tokens por minuto, mostrado no dashboard; peça ao suporte e ele pode ser aumentado.

Para volumes maiores, retentativas e concorrência são mais fáceis em código: as páginas [Python](https://llmwithcrypto.com/pt/docs/python/) e [Node.js](https://llmwithcrypto.com/pt/docs/node/) têm exemplos de lote prontos com limite de concorrência.

## curl: perguntas comuns

### Por que recebo um erro 401?

A chave está ausente, digitada errado ou revogada, ou a variável não está definida neste shell. Rode `echo ${#LLMWITHCRYPTO_API_KEY}` para verificar se ela não está vazia.

### Como faço para comparar dois modelos rapidamente?

Rode o mesmo arquivo duas vezes e altere apenas `model`, por exemplo `deepseek-v4-pro` e `gpt-oss-120b`; as linhas `usage` mostram quanto cada resposta custou em tokens.

### Meu prompt é armazenado?

Não. 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.

---

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.